gcc/gcc.c

   1 /* Compiler driver program that can handle many languages.
   2    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
   4    2010, 2011, 2012
   5    Free Software Foundation, Inc.
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 3, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23 /* This program is the user interface to the C compiler and possibly to
  24 other compilers.  It is used because compilation is a complicated procedure
  25 which involves running several programs and passing temporary files between
  26 them, forwarding the users switches to those programs selectively,
  27 and deleting the temporary files at the end.
  28
  29 CC recognizes how to compile each input file by suffixes in the file names.
  30 Once it knows which kind of compilation to perform, the procedure for
  31 compilation is specified by a string called a "spec".  */
  32
  33 #include "config.h"
  34 #include "system.h"
  35 #include "coretypes.h"
  36 #include "multilib.h" /* before tm.h */
  37 #include "tm.h"
  38 #include "xregex.h"
  39 #include "obstack.h"
  40 #include "intl.h"
  41 #include "prefix.h"
  42 #include "gcc.h"
  43 #include "diagnostic.h"
  44 #include "flags.h"
  45 #include "opts.h"
  46 #include "params.h"
  47 #include "vec.h"
  48 #include "filenames.h"
  49
  50 /* By default there is no special suffix for target executables.  */
  51 /* FIXME: when autoconf is fixed, remove the host check - dj */
  52 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
  53 #define HAVE_TARGET_EXECUTABLE_SUFFIX
  54 #endif
  55
  56 /* By default there is no special suffix for host executables.  */
  57 #ifdef HOST_EXECUTABLE_SUFFIX
  58 #define HAVE_HOST_EXECUTABLE_SUFFIX
  59 #else
  60 #define HOST_EXECUTABLE_SUFFIX ""
  61 #endif
  62
  63 /* By default, the suffix for target object files is ".o".  */
  64 #ifdef TARGET_OBJECT_SUFFIX
  65 #define HAVE_TARGET_OBJECT_SUFFIX
  66 #else
  67 #define TARGET_OBJECT_SUFFIX ".o"
  68 #endif
  69
  70 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
  71
  72 /* Most every one is fine with LIBRARY_PATH.  For some, it conflicts.  */
  73 #ifndef LIBRARY_PATH_ENV
  74 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
  75 #endif
  76
  77 /* If a stage of compilation returns an exit status >= 1,
  78    compilation of that file ceases.  */
  79
  80 #define MIN_FATAL_STATUS 1
  81
  82 /* Flag set by cppspec.c to 1.  */
  83 int is_cpp_driver;
  84
  85 /* Flag set to nonzero if an @file argument has been supplied to gcc.  */
  86 static bool at_file_supplied;
  87
  88 /* Definition of string containing the arguments given to configure.  */
  89 #include "configargs.h"
  90
  91 /* Flag saying to print the command line options understood by gcc and its
  92    sub-processes.  */
  93
  94 static int print_help_list;
  95
  96 /* Flag saying to print the version of gcc and its sub-processes.  */
  97
  98 static int print_version;
  99
 100 /* Flag indicating whether we should ONLY print the command and
 101    arguments (like verbose_flag) without executing the command.
 102    Displayed arguments are quoted so that the generated command
 103    line is suitable for execution.  This is intended for use in
 104    shell scripts to capture the driver-generated command line.  */
 105 static int verbose_only_flag;
 106
 107 /* Flag indicating how to print command line options of sub-processes.  */
 108
 109 static int print_subprocess_help;
 110
 111 /* Whether we should report subprocess execution times to a file.  */
 112
 113 FILE *report_times_to_file = NULL;
 114
 115 /* Nonzero means place this string before uses of /, so that include
 116    and library files can be found in an alternate location.  */
 117
 118 #ifdef TARGET_SYSTEM_ROOT
 119 static const char *target_system_root = TARGET_SYSTEM_ROOT;
 120 #else
 121 static const char *target_system_root = 0;
 122 #endif
 123
 124 /* Nonzero means pass the updated target_system_root to the compiler.  */
 125
 126 static int target_system_root_changed;
 127
 128 /* Nonzero means append this string to target_system_root.  */
 129
 130 static const char *target_sysroot_suffix = 0;
 131
 132 /* Nonzero means append this string to target_system_root for headers.  */
 133
 134 static const char *target_sysroot_hdrs_suffix = 0;
 135
 136 /* Nonzero means write "temp" files in source directory
 137    and use the source file's name in them, and don't delete them.  */
 138
 139 static enum save_temps {
 140   SAVE_TEMPS_NONE,              /* no -save-temps */
 141   SAVE_TEMPS_CWD,               /* -save-temps in current directory */
 142   SAVE_TEMPS_OBJ                /* -save-temps in object directory */
 143 } save_temps_flag;
 144
 145 /* Output file to use to get the object directory for -save-temps=obj  */
 146 static char *save_temps_prefix = 0;
 147 static size_t save_temps_length = 0;
 148
 149 /* The compiler version.  */
 150
 151 static const char *compiler_version;
 152
 153 /* The target version.  */
 154
 155 static const char *const spec_version = DEFAULT_TARGET_VERSION;
 156
 157 /* The target machine.  */
 158
 159 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
 160
 161 /* Nonzero if cross-compiling.
 162    When -b is used, the value comes from the `specs' file.  */
 163
 164 #ifdef CROSS_DIRECTORY_STRUCTURE
 165 static const char *cross_compile = "1";
 166 #else
 167 static const char *cross_compile = "0";
 168 #endif
 169
 170 /* Greatest exit code of sub-processes that has been encountered up to
 171    now.  */
 172 static int greatest_status = 1;
 173
 174 /* This is the obstack which we use to allocate many strings.  */
 175
 176 static struct obstack obstack;
 177
 178 /* This is the obstack to build an environment variable to pass to
 179    collect2 that describes all of the relevant switches of what to
 180    pass the compiler in building the list of pointers to constructors
 181    and destructors.  */
 182
 183 static struct obstack collect_obstack;
 184
 185 /* Forward declaration for prototypes.  */
 186 struct path_prefix;
 187 struct prefix_list;
 188
 189 static void init_spec (void);
 190 static void store_arg (const char *, int, int);
 191 static void insert_wrapper (const char *);
 192 static char *load_specs (const char *);
 193 static void read_specs (const char *, 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
 442 The conditional text X in a %{S:X} or similar construct may contain
 443 other nested % constructs or spaces, or even newlines.  They are
 444 processed as usual, as described above.  Trailing white space in X is
 445 ignored.  White space may also appear anywhere on the left side of the
 446 colon in these constructs, except between . or * and the corresponding
 447 word.
 448
 449 The -O, -f, -m, and -W switches are handled specifically in these
 450 constructs.  If another value of -O or the negated form of a -f, -m, or
 451 -W switch is found later in the command line, the earlier switch
 452 value is ignored, except with {S*} where S is just one letter; this
 453 passes all matching options.
 454
 455 The character | at the beginning of the predicate text is used to indicate
 456 that a command should be piped to the following command, but only if -pipe
 457 is specified.
 458
 459 Note that it is built into GCC which switches take arguments and which
 460 do not.  You might think it would be useful to generalize this to
 461 allow each compiler's spec to say which switches take arguments.  But
 462 this cannot be done in a consistent fashion.  GCC cannot even decide
 463 which input files have been specified without knowing which switches
 464 take arguments, and it must know which input files to compile in order
 465 to tell which compilers to run.
 466
 467 GCC also knows implicitly that arguments starting in `-l' are to be
 468 treated as compiler output files, and passed to the linker in their
 469 proper position among the other output files.  */
 470 \f
 471 /* Define the macros used for specs %a, %l, %L, %S, %C, %1.  */
 472
 473 /* config.h can define ASM_SPEC to provide extra args to the assembler
 474    or extra switch-translations.  */
 475 #ifndef ASM_SPEC
 476 #define ASM_SPEC ""
 477 #endif
 478
 479 /* config.h can define ASM_FINAL_SPEC to run a post processor after
 480    the assembler has run.  */
 481 #ifndef ASM_FINAL_SPEC
 482 #define ASM_FINAL_SPEC ""
 483 #endif
 484
 485 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
 486    or extra switch-translations.  */
 487 #ifndef CPP_SPEC
 488 #define CPP_SPEC ""
 489 #endif
 490
 491 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
 492    or extra switch-translations.  */
 493 #ifndef CC1_SPEC
 494 #define CC1_SPEC ""
 495 #endif
 496
 497 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
 498    or extra switch-translations.  */
 499 #ifndef CC1PLUS_SPEC
 500 #define CC1PLUS_SPEC ""
 501 #endif
 502
 503 /* config.h can define LINK_SPEC to provide extra args to the linker
 504    or extra switch-translations.  */
 505 #ifndef LINK_SPEC
 506 #define LINK_SPEC ""
 507 #endif
 508
 509 /* config.h can define LIB_SPEC to override the default libraries.  */
 510 #ifndef LIB_SPEC
 511 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
 512 #endif
 513
 514 /* mudflap specs */
 515 #ifndef MFWRAP_SPEC
 516 /* XXX: valid only for GNU ld */
 517 /* XXX: should exactly match hooks provided by libmudflap.a */
 518 #define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
 519  --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
 520  --wrap=mmap --wrap=mmap64 --wrap=munmap --wrap=alloca\
 521 } %{fmudflapth: --wrap=pthread_create\
 522 }} %{fmudflap|fmudflapth: --wrap=main}"
 523 #endif
 524 #ifndef MFLIB_SPEC
 525 #define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
 526 #endif
 527
 528 /* When using -fsplit-stack we need to wrap pthread_create, in order
 529    to initialize the stack guard.  We always use wrapping, rather than
 530    shared library ordering, and we keep the wrapper function in
 531    libgcc.  This is not yet a real spec, though it could become one;
 532    it is currently just stuffed into LINK_SPEC.  FIXME: This wrapping
 533    only works with GNU ld and gold.  FIXME: This is incompatible with
 534    -fmudflap when linking statically, which wants to do its own
 535    wrapping.  */
 536 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
 537
 538 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
 539    included.  */
 540 #ifndef LIBGCC_SPEC
 541 #if defined(REAL_LIBGCC_SPEC)
 542 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
 543 #elif defined(LINK_LIBGCC_SPECIAL_1)
 544 /* Have gcc do the search for libgcc.a.  */
 545 #define LIBGCC_SPEC "libgcc.a%s"
 546 #else
 547 #define LIBGCC_SPEC "-lgcc"
 548 #endif
 549 #endif
 550
 551 /* config.h can define STARTFILE_SPEC to override the default crt0 files.  */
 552 #ifndef STARTFILE_SPEC
 553 #define STARTFILE_SPEC  \
 554   "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
 555 #endif
 556
 557 /* config.h can define ENDFILE_SPEC to override the default crtn files.  */
 558 #ifndef ENDFILE_SPEC
 559 #define ENDFILE_SPEC ""
 560 #endif
 561
 562 #ifndef LINKER_NAME
 563 #define LINKER_NAME "collect2"
 564 #endif
 565
 566 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
 567 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
 568 #else
 569 #define ASM_MAP ""
 570 #endif
 571
 572 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
 573    to the assembler.  */
 574 #ifndef ASM_DEBUG_SPEC
 575 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
 576      && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
 577 #  define ASM_DEBUG_SPEC                                                \
 578       (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG                            \
 579        ? "%{!g0:%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}}" ASM_MAP    \
 580        : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
 581 # else
 582 #  if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
 583 #   define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
 584 #  endif
 585 #  if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
 586 #   define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
 587 #  endif
 588 # endif
 589 #endif
 590 #ifndef ASM_DEBUG_SPEC
 591 # define ASM_DEBUG_SPEC ""
 592 #endif
 593
 594 /* Here is the spec for running the linker, after compiling all files.  */
 595
 596 /* This is overridable by the target in case they need to specify the
 597    -lgcc and -lc order specially, yet not require them to override all
 598    of LINK_COMMAND_SPEC.  */
 599 #ifndef LINK_GCC_C_SEQUENCE_SPEC
 600 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
 601 #endif
 602
 603 #ifndef LINK_SSP_SPEC
 604 #ifdef TARGET_LIBC_PROVIDES_SSP
 605 #define LINK_SSP_SPEC "%{fstack-protector:}"
 606 #else
 607 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
 608 #endif
 609 #endif
 610
 611 #ifndef LINK_PIE_SPEC
 612 #ifdef HAVE_LD_PIE
 613 #define LINK_PIE_SPEC "%{pie:-pie} "
 614 #else
 615 #define LINK_PIE_SPEC "%{pie:} "
 616 #endif
 617 #endif
 618
 619 #ifndef LINK_BUILDID_SPEC
 620 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
 621 #  define LINK_BUILDID_SPEC "%{!r:--build-id} "
 622 # endif
 623 #endif
 624
 625 /* Conditional to test whether the LTO plugin is used or not.
 626    FIXME: For slim LTO we will need to enable plugin unconditionally.  This
 627    still cause problems with PLUGIN_LD != LD and when plugin is built but
 628    not useable.  For GCC 4.6 we don't support slim LTO and thus we can enable
 629    plugin only when LTO is enabled.  We still honor explicit
 630    -fuse-linker-plugin if the linker used understands -plugin.  */
 631
 632 /* The linker has some plugin support.  */
 633 #if HAVE_LTO_PLUGIN > 0
 634 /* The linker used has full plugin support, use LTO plugin by default.  */
 635 #if HAVE_LTO_PLUGIN == 2
 636 #define PLUGIN_COND "!fno-use-linker-plugin:%{flto|flto=*|fuse-linker-plugin"
 637 #define PLUGIN_COND_CLOSE "}"
 638 #else
 639 /* The linker used has limited plugin support, use LTO plugin with explicit
 640    -fuse-linker-plugin.  */
 641 #define PLUGIN_COND "fuse-linker-plugin"
 642 #define PLUGIN_COND_CLOSE ""
 643 #endif
 644 #define LINK_PLUGIN_SPEC \
 645     "%{"PLUGIN_COND": \
 646     -plugin %(linker_plugin_file) \
 647     -plugin-opt=%(lto_wrapper) \
 648     -plugin-opt=-fresolution=%u.res \
 649     %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
 650     }"PLUGIN_COND_CLOSE
 651 #else
 652 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin.  */
 653 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
 654     %e-fuse-linker-plugin is not supported in this configuration}"
 655 #endif
 656
 657
 658 /* -u* was put back because both BSD and SysV seem to support it.  */
 659 /* %{static:} simply prevents an error message if the target machine
 660    doesn't handle -static.  */
 661 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
 662    scripts which exist in user specified directories, or in standard
 663    directories.  */
 664 /* We pass any -flto flags on to the linker, which is expected
 665    to understand them.  In practice, this means it had better be collect2.  */
 666 /* %{e*} includes -export-dynamic; see comment in common.opt.  */
 667 #ifndef LINK_COMMAND_SPEC
 668 #define LINK_COMMAND_SPEC "\
 669 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
 670     %(linker) " \
 671     LINK_PLUGIN_SPEC \
 672     "%{flto|flto=*:%<fcompare-debug*} \
 673     %{flto} %{flto=*} %l " LINK_PIE_SPEC \
 674    "%X %{o*} %{e*} %{N} %{n} %{r}\
 675     %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!nostartfiles:%S}}\
 676     %{static:} %{L*} %(mfwrap) %(link_libgcc) %o\
 677     %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)}\
 678     %(mflib) " STACK_SPLIT_SPEC "\
 679     %{fprofile-arcs|fprofile-generate*|coverage:-lgcov}\
 680     %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
 681     %{!nostdlib:%{!nostartfiles:%E}} %{T*} }}}}}}"
 682 #endif
 683
 684 #ifndef LINK_LIBGCC_SPEC
 685 /* Generate -L options for startfile prefix list.  */
 686 # define LINK_LIBGCC_SPEC "%D"
 687 #endif
 688
 689 #ifndef STARTFILE_PREFIX_SPEC
 690 # define STARTFILE_PREFIX_SPEC ""
 691 #endif
 692
 693 #ifndef SYSROOT_SPEC
 694 # define SYSROOT_SPEC "--sysroot=%R"
 695 #endif
 696
 697 #ifndef SYSROOT_SUFFIX_SPEC
 698 # define SYSROOT_SUFFIX_SPEC ""
 699 #endif
 700
 701 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
 702 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
 703 #endif
 704
 705 static const char *asm_debug;
 706 static const char *cpp_spec = CPP_SPEC;
 707 static const char *cc1_spec = CC1_SPEC;
 708 static const char *cc1plus_spec = CC1PLUS_SPEC;
 709 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
 710 static const char *link_ssp_spec = LINK_SSP_SPEC;
 711 static const char *asm_spec = ASM_SPEC;
 712 static const char *asm_final_spec = ASM_FINAL_SPEC;
 713 static const char *link_spec = LINK_SPEC;
 714 static const char *lib_spec = LIB_SPEC;
 715 static const char *mfwrap_spec = MFWRAP_SPEC;
 716 static const char *mflib_spec = MFLIB_SPEC;
 717 static const char *link_gomp_spec = "";
 718 static const char *libgcc_spec = LIBGCC_SPEC;
 719 static const char *endfile_spec = ENDFILE_SPEC;
 720 static const char *startfile_spec = STARTFILE_SPEC;
 721 static const char *linker_name_spec = LINKER_NAME;
 722 static const char *linker_plugin_file_spec = "";
 723 static const char *lto_wrapper_spec = "";
 724 static const char *lto_gcc_spec = "";
 725 static const char *link_command_spec = LINK_COMMAND_SPEC;
 726 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
 727 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
 728 static const char *sysroot_spec = SYSROOT_SPEC;
 729 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
 730 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
 731 static const char *self_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) in a compiler or link
1153    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   INIT_STATIC_SPEC ("self_spec",                &self_spec),
1220 };
1221
1222 #ifdef EXTRA_SPECS              /* additional specs needed */
1223 /* Structure to keep track of just the first two args of a spec_list.
1224    That is all that the EXTRA_SPECS macro gives us.  */
1225 struct spec_list_1
1226 {
1227   const char *const name;
1228   const char *const ptr;
1229 };
1230
1231 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1232 static struct spec_list *extra_specs = (struct spec_list *) 0;
1233 #endif
1234
1235 /* List of dynamically allocates specs that have been defined so far.  */
1236
1237 static struct spec_list *specs = (struct spec_list *) 0;
1238 \f
1239 /* List of static spec functions.  */
1240
1241 static const struct spec_function static_spec_functions[] =
1242 {
1243   { "getenv",                   getenv_spec_function },
1244   { "if-exists",                if_exists_spec_function },
1245   { "if-exists-else",           if_exists_else_spec_function },
1246   { "replace-outfile",          replace_outfile_spec_function },
1247   { "remove-outfile",           remove_outfile_spec_function },
1248   { "version-compare",          version_compare_spec_function },
1249   { "include",                  include_spec_function },
1250   { "find-file",                find_file_spec_function },
1251   { "find-plugindir",           find_plugindir_spec_function },
1252   { "print-asm-header",         print_asm_header_spec_function },
1253   { "compare-debug-dump-opt",   compare_debug_dump_opt_spec_function },
1254   { "compare-debug-self-opt",   compare_debug_self_opt_spec_function },
1255   { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function },
1256   { "pass-through-libs",        pass_through_libs_spec_func },
1257 #ifdef EXTRA_SPEC_FUNCTIONS
1258   EXTRA_SPEC_FUNCTIONS
1259 #endif
1260   { 0, 0 }
1261 };
1262
1263 static int processing_spec_function;
1264 \f
1265 /* Add appropriate libgcc specs to OBSTACK, taking into account
1266    various permutations of -shared-libgcc, -shared, and such.  */
1267
1268 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1269
1270 #ifndef USE_LD_AS_NEEDED
1271 #define USE_LD_AS_NEEDED 0
1272 #endif
1273
1274 static void
1275 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1276                 const char *static_name, const char *eh_name)
1277 {
1278   char *buf;
1279
1280   buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
1281                 "%{!static:%{!static-libgcc:"
1282 #if USE_LD_AS_NEEDED
1283                 "%{!shared-libgcc:",
1284                 static_name, " --as-needed ", shared_name, " --no-as-needed"
1285                 "}"
1286                 "%{shared-libgcc:",
1287                 shared_name, "%{!shared: ", static_name, "}"
1288                 "}"
1289 #else
1290                 "%{!shared:"
1291                 "%{!shared-libgcc:", static_name, " ", eh_name, "}"
1292                 "%{shared-libgcc:", shared_name, " ", static_name, "}"
1293                 "}"
1294 #ifdef LINK_EH_SPEC
1295                 "%{shared:"
1296                 "%{shared-libgcc:", shared_name, "}"
1297                 "%{!shared-libgcc:", static_name, "}"
1298                 "}"
1299 #else
1300                 "%{shared:", shared_name, "}"
1301 #endif
1302 #endif
1303                 "}}", NULL);
1304
1305   obstack_grow (obstack, buf, strlen (buf));
1306   free (buf);
1307 }
1308 #endif /* ENABLE_SHARED_LIBGCC */
1309
1310 /* Initialize the specs lookup routines.  */
1311
1312 static void
1313 init_spec (void)
1314 {
1315   struct spec_list *next = (struct spec_list *) 0;
1316   struct spec_list *sl   = (struct spec_list *) 0;
1317   int i;
1318
1319   if (specs)
1320     return;                     /* Already initialized.  */
1321
1322   if (verbose_flag)
1323     fnotice (stderr, "Using built-in specs.\n");
1324
1325 #ifdef EXTRA_SPECS
1326   extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
1327
1328   for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1329     {
1330       sl = &extra_specs[i];
1331       sl->name = extra_specs_1[i].name;
1332       sl->ptr = extra_specs_1[i].ptr;
1333       sl->next = next;
1334       sl->name_len = strlen (sl->name);
1335       sl->ptr_spec = &sl->ptr;
1336       next = sl;
1337     }
1338 #endif
1339
1340   for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1341     {
1342       sl = &static_specs[i];
1343       sl->next = next;
1344       next = sl;
1345     }
1346
1347 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1348   /* ??? If neither -shared-libgcc nor --static-libgcc was
1349      seen, then we should be making an educated guess.  Some proposed
1350      heuristics for ELF include:
1351
1352         (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1353             program will be doing dynamic loading, which will likely
1354             need the shared libgcc.
1355
1356         (2) If "-ldl", then it's also a fair bet that we're doing
1357             dynamic loading.
1358
1359         (3) For each ET_DYN we're linking against (either through -lfoo
1360             or /some/path/foo.so), check to see whether it or one of
1361             its dependencies depends on a shared libgcc.
1362
1363         (4) If "-shared"
1364
1365             If the runtime is fixed to look for program headers instead
1366             of calling __register_frame_info at all, for each object,
1367             use the shared libgcc if any EH symbol referenced.
1368
1369             If crtstuff is fixed to not invoke __register_frame_info
1370             automatically, for each object, use the shared libgcc if
1371             any non-empty unwind section found.
1372
1373      Doing any of this probably requires invoking an external program to
1374      do the actual object file scanning.  */
1375   {
1376     const char *p = libgcc_spec;
1377     int in_sep = 1;
1378
1379     /* Transform the extant libgcc_spec into one that uses the shared libgcc
1380        when given the proper command line arguments.  */
1381     while (*p)
1382       {
1383         if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1384           {
1385             init_gcc_specs (&obstack,
1386                             "-lgcc_s"
1387 #ifdef USE_LIBUNWIND_EXCEPTIONS
1388                             " -lunwind"
1389 #endif
1390                             ,
1391                             "-lgcc",
1392                             "-lgcc_eh"
1393 #ifdef USE_LIBUNWIND_EXCEPTIONS
1394 # ifdef HAVE_LD_STATIC_DYNAMIC
1395                             " %{!static:" LD_STATIC_OPTION "} -lunwind"
1396                             " %{!static:" LD_DYNAMIC_OPTION "}"
1397 # else
1398                             " -lunwind"
1399 # endif
1400 #endif
1401                             );
1402
1403             p += 5;
1404             in_sep = 0;
1405           }
1406         else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1407           {
1408             /* Ug.  We don't know shared library extensions.  Hope that
1409                systems that use this form don't do shared libraries.  */
1410             init_gcc_specs (&obstack,
1411                             "-lgcc_s",
1412                             "libgcc.a%s",
1413                             "libgcc_eh.a%s"
1414 #ifdef USE_LIBUNWIND_EXCEPTIONS
1415                             " -lunwind"
1416 #endif
1417                             );
1418             p += 10;
1419             in_sep = 0;
1420           }
1421         else
1422           {
1423             obstack_1grow (&obstack, *p);
1424             in_sep = (*p == ' ');
1425             p += 1;
1426           }
1427       }
1428
1429     obstack_1grow (&obstack, '\0');
1430     libgcc_spec = XOBFINISH (&obstack, const char *);
1431   }
1432 #endif
1433 #ifdef USE_AS_TRADITIONAL_FORMAT
1434   /* Prepend "--traditional-format" to whatever asm_spec we had before.  */
1435   {
1436     static const char tf[] = "--traditional-format ";
1437     obstack_grow (&obstack, tf, sizeof(tf) - 1);
1438     obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1439     asm_spec = XOBFINISH (&obstack, const char *);
1440   }
1441 #endif
1442
1443 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1444     defined LINKER_HASH_STYLE
1445 # ifdef LINK_BUILDID_SPEC
1446   /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before.  */
1447   obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof(LINK_BUILDID_SPEC) - 1);
1448 # endif
1449 # ifdef LINK_EH_SPEC
1450   /* Prepend LINK_EH_SPEC to whatever link_spec we had before.  */
1451   obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1452 # endif
1453 # ifdef LINKER_HASH_STYLE
1454   /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1455      before.  */
1456   {
1457     static const char hash_style[] = "--hash-style=";
1458     obstack_grow (&obstack, hash_style, sizeof(hash_style) - 1);
1459     obstack_grow (&obstack, LINKER_HASH_STYLE, sizeof(LINKER_HASH_STYLE) - 1);
1460     obstack_1grow (&obstack, ' ');
1461   }
1462 # endif
1463   obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1464   link_spec = XOBFINISH (&obstack, const char *);
1465 #endif
1466
1467   specs = sl;
1468 }
1469 \f
1470 /* Change the value of spec NAME to SPEC.  If SPEC is empty, then the spec is
1471    removed; If the spec starts with a + then SPEC is added to the end of the
1472    current spec.  */
1473
1474 static void
1475 set_spec (const char *name, const char *spec)
1476 {
1477   struct spec_list *sl;
1478   const char *old_spec;
1479   int name_len = strlen (name);
1480   int i;
1481
1482   /* If this is the first call, initialize the statically allocated specs.  */
1483   if (!specs)
1484     {
1485       struct spec_list *next = (struct spec_list *) 0;
1486       for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1487         {
1488           sl = &static_specs[i];
1489           sl->next = next;
1490           next = sl;
1491         }
1492       specs = sl;
1493     }
1494
1495   /* See if the spec already exists.  */
1496   for (sl = specs; sl; sl = sl->next)
1497     if (name_len == sl->name_len && !strcmp (sl->name, name))
1498       break;
1499
1500   if (!sl)
1501     {
1502       /* Not found - make it.  */
1503       sl = XNEW (struct spec_list);
1504       sl->name = xstrdup (name);
1505       sl->name_len = name_len;
1506       sl->ptr_spec = &sl->ptr;
1507       sl->alloc_p = 0;
1508       *(sl->ptr_spec) = "";
1509       sl->next = specs;
1510       specs = sl;
1511     }
1512
1513   old_spec = *(sl->ptr_spec);
1514   *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1515                      ? concat (old_spec, spec + 1, NULL)
1516                      : xstrdup (spec));
1517
1518 #ifdef DEBUG_SPECS
1519   if (verbose_flag)
1520     fnotice (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1521 #endif
1522
1523   /* Free the old spec.  */
1524   if (old_spec && sl->alloc_p)
1525     free (CONST_CAST(char *, old_spec));
1526
1527   sl->alloc_p = 1;
1528 }
1529 \f
1530 /* Accumulate a command (program name and args), and run it.  */
1531
1532 typedef const char *const_char_p; /* For DEF_VEC_P.  */
1533 DEF_VEC_P(const_char_p);
1534 DEF_VEC_ALLOC_P(const_char_p,heap);
1535
1536 /* Vector of pointers to arguments in the current line of specifications.  */
1537
1538 static VEC(const_char_p,heap) *argbuf;
1539
1540 /* Position in the argbuf vector containing the name of the output file
1541    (the value associated with the "-o" flag).  */
1542
1543 static int have_o_argbuf_index = 0;
1544
1545 /* Were the options -c, -S or -E passed.  */
1546 static int have_c = 0;
1547
1548 /* Was the option -o passed.  */
1549 static int have_o = 0;
1550
1551 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1552    temp file.  If the HOST_BIT_BUCKET is used for %j, no entry is made for
1553    it here.  */
1554
1555 static struct temp_name {
1556   const char *suffix;   /* suffix associated with the code.  */
1557   int length;           /* strlen (suffix).  */
1558   int unique;           /* Indicates whether %g or %u/%U was used.  */
1559   const char *filename; /* associated filename.  */
1560   int filename_length;  /* strlen (filename).  */
1561   struct temp_name *next;
1562 } *temp_names;
1563
1564 /* Number of commands executed so far.  */
1565
1566 static int execution_count;
1567
1568 /* Number of commands that exited with a signal.  */
1569
1570 static int signal_count;
1571 \f
1572 /* Allocate the argument vector.  */
1573
1574 static void
1575 alloc_args (void)
1576 {
1577   argbuf = VEC_alloc (const_char_p, heap, 10);
1578 }
1579
1580 /* Clear out the vector of arguments (after a command is executed).  */
1581
1582 static void
1583 clear_args (void)
1584 {
1585   VEC_truncate (const_char_p, argbuf, 0);
1586 }
1587
1588 /* Add one argument to the vector at the end.
1589    This is done when a space is seen or at the end of the line.
1590    If DELETE_ALWAYS is nonzero, the arg is a filename
1591     and the file should be deleted eventually.
1592    If DELETE_FAILURE is nonzero, the arg is a filename
1593     and the file should be deleted if this compilation fails.  */
1594
1595 static void
1596 store_arg (const char *arg, int delete_always, int delete_failure)
1597 {
1598   VEC_safe_push (const_char_p, heap, argbuf, arg);
1599
1600   if (strcmp (arg, "-o") == 0)
1601     have_o_argbuf_index = VEC_length (const_char_p, argbuf);
1602   if (delete_always || delete_failure)
1603     {
1604       const char *p;
1605       /* If the temporary file we should delete is specified as
1606          part of a joined argument extract the filename.  */
1607       if (arg[0] == '-'
1608           && (p = strrchr (arg, '=')))
1609         arg = p + 1;
1610       record_temp_file (arg, delete_always, delete_failure);
1611     }
1612 }
1613 \f
1614 /* Load specs from a file name named FILENAME, replacing occurrences of
1615    various different types of line-endings, \r\n, \n\r and just \r, with
1616    a single \n.  */
1617
1618 static char *
1619 load_specs (const char *filename)
1620 {
1621   int desc;
1622   int readlen;
1623   struct stat statbuf;
1624   char *buffer;
1625   char *buffer_p;
1626   char *specs;
1627   char *specs_p;
1628
1629   if (verbose_flag)
1630     fnotice (stderr, "Reading specs from %s\n", filename);
1631
1632   /* Open and stat the file.  */
1633   desc = open (filename, O_RDONLY, 0);
1634   if (desc < 0)
1635     pfatal_with_name (filename);
1636   if (stat (filename, &statbuf) < 0)
1637     pfatal_with_name (filename);
1638
1639   /* Read contents of file into BUFFER.  */
1640   buffer = XNEWVEC (char, statbuf.st_size + 1);
1641   readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1642   if (readlen < 0)
1643     pfatal_with_name (filename);
1644   buffer[readlen] = 0;
1645   close (desc);
1646
1647   specs = XNEWVEC (char, readlen + 1);
1648   specs_p = specs;
1649   for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1650     {
1651       int skip = 0;
1652       char c = *buffer_p;
1653       if (c == '\r')
1654         {
1655           if (buffer_p > buffer && *(buffer_p - 1) == '\n')     /* \n\r */
1656             skip = 1;
1657           else if (*(buffer_p + 1) == '\n')                     /* \r\n */
1658             skip = 1;
1659           else                                                  /* \r */
1660             c = '\n';
1661         }
1662       if (! skip)
1663         *specs_p++ = c;
1664     }
1665   *specs_p = '\0';
1666
1667   free (buffer);
1668   return (specs);
1669 }
1670
1671 /* Read compilation specs from a file named FILENAME,
1672    replacing the default ones.
1673
1674    A suffix which starts with `*' is a definition for
1675    one of the machine-specific sub-specs.  The "suffix" should be
1676    *asm, *cc1, *cpp, *link, *startfile, etc.
1677    The corresponding spec is stored in asm_spec, etc.,
1678    rather than in the `compilers' vector.
1679
1680    Anything invalid in the file is a fatal error.  */
1681
1682 static void
1683 read_specs (const char *filename, int main_p)
1684 {
1685   char *buffer;
1686   char *p;
1687
1688   buffer = load_specs (filename);
1689
1690   /* Scan BUFFER for specs, putting them in the vector.  */
1691   p = buffer;
1692   while (1)
1693     {
1694       char *suffix;
1695       char *spec;
1696       char *in, *out, *p1, *p2, *p3;
1697
1698       /* Advance P in BUFFER to the next nonblank nocomment line.  */
1699       p = skip_whitespace (p);
1700       if (*p == 0)
1701         break;
1702
1703       /* Is this a special command that starts with '%'? */
1704       /* Don't allow this for the main specs file, since it would
1705          encourage people to overwrite it.  */
1706       if (*p == '%' && !main_p)
1707         {
1708           p1 = p;
1709           while (*p && *p != '\n')
1710             p++;
1711
1712           /* Skip '\n'.  */
1713           p++;
1714
1715           if (!strncmp (p1, "%include", sizeof ("%include") - 1)
1716               && (p1[sizeof "%include" - 1] == ' '
1717                   || p1[sizeof "%include" - 1] == '\t'))
1718             {
1719               char *new_filename;
1720
1721               p1 += sizeof ("%include");
1722               while (*p1 == ' ' || *p1 == '\t')
1723                 p1++;
1724
1725               if (*p1++ != '<' || p[-2] != '>')
1726                 fatal_error ("specs %%include syntax malformed after "
1727                              "%ld characters",
1728                              (long) (p1 - buffer + 1));
1729
1730               p[-2] = '\0';
1731               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
1732               read_specs (new_filename ? new_filename : p1, FALSE);
1733               continue;
1734             }
1735           else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
1736                    && (p1[sizeof "%include_noerr" - 1] == ' '
1737                        || p1[sizeof "%include_noerr" - 1] == '\t'))
1738             {
1739               char *new_filename;
1740
1741               p1 += sizeof "%include_noerr";
1742               while (*p1 == ' ' || *p1 == '\t')
1743                 p1++;
1744
1745               if (*p1++ != '<' || p[-2] != '>')
1746                 fatal_error ("specs %%include syntax malformed after "
1747                              "%ld characters",
1748                              (long) (p1 - buffer + 1));
1749
1750               p[-2] = '\0';
1751               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
1752               if (new_filename)
1753                 read_specs (new_filename, FALSE);
1754               else if (verbose_flag)
1755                 fnotice (stderr, "could not find specs file %s\n", p1);
1756               continue;
1757             }
1758           else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
1759                    && (p1[sizeof "%rename" - 1] == ' '
1760                        || p1[sizeof "%rename" - 1] == '\t'))
1761             {
1762               int name_len;
1763               struct spec_list *sl;
1764               struct spec_list *newsl;
1765
1766               /* Get original name.  */
1767               p1 += sizeof "%rename";
1768               while (*p1 == ' ' || *p1 == '\t')
1769                 p1++;
1770
1771               if (! ISALPHA ((unsigned char) *p1))
1772                 fatal_error ("specs %%rename syntax malformed after "
1773                              "%ld characters",
1774                              (long) (p1 - buffer));
1775
1776               p2 = p1;
1777               while (*p2 && !ISSPACE ((unsigned char) *p2))
1778                 p2++;
1779
1780               if (*p2 != ' ' && *p2 != '\t')
1781                 fatal_error ("specs %%rename syntax malformed after "
1782                              "%ld characters",
1783                              (long) (p2 - buffer));
1784
1785               name_len = p2 - p1;
1786               *p2++ = '\0';
1787               while (*p2 == ' ' || *p2 == '\t')
1788                 p2++;
1789
1790               if (! ISALPHA ((unsigned char) *p2))
1791                 fatal_error ("specs %%rename syntax malformed after "
1792                              "%ld characters",
1793                              (long) (p2 - buffer));
1794
1795               /* Get new spec name.  */
1796               p3 = p2;
1797               while (*p3 && !ISSPACE ((unsigned char) *p3))
1798                 p3++;
1799
1800               if (p3 != p - 1)
1801                 fatal_error ("specs %%rename syntax malformed after "
1802                              "%ld characters",
1803                              (long) (p3 - buffer));
1804               *p3 = '\0';
1805
1806               for (sl = specs; sl; sl = sl->next)
1807                 if (name_len == sl->name_len && !strcmp (sl->name, p1))
1808                   break;
1809
1810               if (!sl)
1811                 fatal_error ("specs %s spec was not found to be renamed", p1);
1812
1813               if (strcmp (p1, p2) == 0)
1814                 continue;
1815
1816               for (newsl = specs; newsl; newsl = newsl->next)
1817                 if (strcmp (newsl->name, p2) == 0)
1818                   fatal_error ("%s: attempt to rename spec %qs to "
1819                                "already defined spec %qs",
1820                     filename, p1, p2);
1821
1822               if (verbose_flag)
1823                 {
1824                   fnotice (stderr, "rename spec %s to %s\n", p1, p2);
1825 #ifdef DEBUG_SPECS
1826                   fnotice (stderr, "spec is '%s'\n\n", *(sl->ptr_spec));
1827 #endif
1828                 }
1829
1830               set_spec (p2, *(sl->ptr_spec));
1831               if (sl->alloc_p)
1832                 free (CONST_CAST (char *, *(sl->ptr_spec)));
1833
1834               *(sl->ptr_spec) = "";
1835               sl->alloc_p = 0;
1836               continue;
1837             }
1838           else
1839             fatal_error ("specs unknown %% command after %ld characters",
1840                          (long) (p1 - buffer));
1841         }
1842
1843       /* Find the colon that should end the suffix.  */
1844       p1 = p;
1845       while (*p1 && *p1 != ':' && *p1 != '\n')
1846         p1++;
1847
1848       /* The colon shouldn't be missing.  */
1849       if (*p1 != ':')
1850         fatal_error ("specs file malformed after %ld characters",
1851                      (long) (p1 - buffer));
1852
1853       /* Skip back over trailing whitespace.  */
1854       p2 = p1;
1855       while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
1856         p2--;
1857
1858       /* Copy the suffix to a string.  */
1859       suffix = save_string (p, p2 - p);
1860       /* Find the next line.  */
1861       p = skip_whitespace (p1 + 1);
1862       if (p[1] == 0)
1863         fatal_error ("specs file malformed after %ld characters",
1864                      (long) (p - buffer));
1865
1866       p1 = p;
1867       /* Find next blank line or end of string.  */
1868       while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
1869         p1++;
1870
1871       /* Specs end at the blank line and do not include the newline.  */
1872       spec = save_string (p, p1 - p);
1873       p = p1;
1874
1875       /* Delete backslash-newline sequences from the spec.  */
1876       in = spec;
1877       out = spec;
1878       while (*in != 0)
1879         {
1880           if (in[0] == '\\' && in[1] == '\n')
1881             in += 2;
1882           else if (in[0] == '#')
1883             while (*in && *in != '\n')
1884               in++;
1885
1886           else
1887             *out++ = *in++;
1888         }
1889       *out = 0;
1890
1891       if (suffix[0] == '*')
1892         {
1893           if (! strcmp (suffix, "*link_command"))
1894             link_command_spec = spec;
1895           else
1896             set_spec (suffix + 1, spec);
1897         }
1898       else
1899         {
1900           /* Add this pair to the vector.  */
1901           compilers
1902             = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
1903
1904           compilers[n_compilers].suffix = suffix;
1905           compilers[n_compilers].spec = spec;
1906           n_compilers++;
1907           memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
1908         }
1909
1910       if (*suffix == 0)
1911         link_command_spec = spec;
1912     }
1913
1914   if (link_command_spec == 0)
1915     fatal_error ("spec file has no spec for linking");
1916 }
1917 \f
1918 /* Record the names of temporary files we tell compilers to write,
1919    and delete them at the end of the run.  */
1920
1921 /* This is the common prefix we use to make temp file names.
1922    It is chosen once for each run of this program.
1923    It is substituted into a spec by %g or %j.
1924    Thus, all temp file names contain this prefix.
1925    In practice, all temp file names start with this prefix.
1926
1927    This prefix comes from the envvar TMPDIR if it is defined;
1928    otherwise, from the P_tmpdir macro if that is defined;
1929    otherwise, in /usr/tmp or /tmp;
1930    or finally the current directory if all else fails.  */
1931
1932 static const char *temp_filename;
1933
1934 /* Length of the prefix.  */
1935
1936 static int temp_filename_length;
1937
1938 /* Define the list of temporary files to delete.  */
1939
1940 struct temp_file
1941 {
1942   const char *name;
1943   struct temp_file *next;
1944 };
1945
1946 /* Queue of files to delete on success or failure of compilation.  */
1947 static struct temp_file *always_delete_queue;
1948 /* Queue of files to delete on failure of compilation.  */
1949 static struct temp_file *failure_delete_queue;
1950
1951 /* Record FILENAME as a file to be deleted automatically.
1952    ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
1953    otherwise delete it in any case.
1954    FAIL_DELETE nonzero means delete it if a compilation step fails;
1955    otherwise delete it in any case.  */
1956
1957 void
1958 record_temp_file (const char *filename, int always_delete, int fail_delete)
1959 {
1960   char *const name = xstrdup (filename);
1961
1962   if (always_delete)
1963     {
1964       struct temp_file *temp;
1965       for (temp = always_delete_queue; temp; temp = temp->next)
1966         if (! filename_cmp (name, temp->name))
1967           goto already1;
1968
1969       temp = XNEW (struct temp_file);
1970       temp->next = always_delete_queue;
1971       temp->name = name;
1972       always_delete_queue = temp;
1973
1974     already1:;
1975     }
1976
1977   if (fail_delete)
1978     {
1979       struct temp_file *temp;
1980       for (temp = failure_delete_queue; temp; temp = temp->next)
1981         if (! filename_cmp (name, temp->name))
1982           goto already2;
1983
1984       temp = XNEW (struct temp_file);
1985       temp->next = failure_delete_queue;
1986       temp->name = name;
1987       failure_delete_queue = temp;
1988
1989     already2:;
1990     }
1991 }
1992
1993 /* Delete all the temporary files whose names we previously recorded.  */
1994
1995 #ifndef DELETE_IF_ORDINARY
1996 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG)        \
1997 do                                                      \
1998   {                                                     \
1999     if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode))  \
2000       if (unlink (NAME) < 0)                            \
2001         if (VERBOSE_FLAG)                               \
2002           perror_with_name (NAME);                      \
2003   } while (0)
2004 #endif
2005
2006 static void
2007 delete_if_ordinary (const char *name)
2008 {
2009   struct stat st;
2010 #ifdef DEBUG
2011   int i, c;
2012
2013   printf ("Delete %s? (y or n) ", name);
2014   fflush (stdout);
2015   i = getchar ();
2016   if (i != '\n')
2017     while ((c = getchar ()) != '\n' && c != EOF)
2018       ;
2019
2020   if (i == 'y' || i == 'Y')
2021 #endif /* DEBUG */
2022   DELETE_IF_ORDINARY (name, st, verbose_flag);
2023 }
2024
2025 static void
2026 delete_temp_files (void)
2027 {
2028   struct temp_file *temp;
2029
2030   for (temp = always_delete_queue; temp; temp = temp->next)
2031     delete_if_ordinary (temp->name);
2032   always_delete_queue = 0;
2033 }
2034
2035 /* Delete all the files to be deleted on error.  */
2036
2037 static void
2038 delete_failure_queue (void)
2039 {
2040   struct temp_file *temp;
2041
2042   for (temp = failure_delete_queue; temp; temp = temp->next)
2043     delete_if_ordinary (temp->name);
2044 }
2045
2046 static void
2047 clear_failure_queue (void)
2048 {
2049   failure_delete_queue = 0;
2050 }
2051 \f
2052 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2053    returns non-NULL.
2054    If DO_MULTI is true iterate over the paths twice, first with multilib
2055    suffix then without, otherwise iterate over the paths once without
2056    adding a multilib suffix.  When DO_MULTI is true, some attempt is made
2057    to avoid visiting the same path twice, but we could do better.  For
2058    instance, /usr/lib/../lib is considered different from /usr/lib.
2059    At least EXTRA_SPACE chars past the end of the path passed to
2060    CALLBACK are available for use by the callback.
2061    CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2062
2063    Returns the value returned by CALLBACK.  */
2064
2065 static void *
2066 for_each_path (const struct path_prefix *paths,
2067                bool do_multi,
2068                size_t extra_space,
2069                void *(*callback) (char *, void *),
2070                void *callback_info)
2071 {
2072   struct prefix_list *pl;
2073   const char *multi_dir = NULL;
2074   const char *multi_os_dir = NULL;
2075   const char *multi_suffix;
2076   const char *just_multi_suffix;
2077   char *path = NULL;
2078   void *ret = NULL;
2079   bool skip_multi_dir = false;
2080   bool skip_multi_os_dir = false;
2081
2082   multi_suffix = machine_suffix;
2083   just_multi_suffix = just_machine_suffix;
2084   if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
2085     {
2086       multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2087       multi_suffix = concat (multi_suffix, multi_dir, NULL);
2088       just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2089     }
2090   if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
2091     multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2092
2093   while (1)
2094     {
2095       size_t multi_dir_len = 0;
2096       size_t multi_os_dir_len = 0;
2097       size_t suffix_len;
2098       size_t just_suffix_len;
2099       size_t len;
2100
2101       if (multi_dir)
2102         multi_dir_len = strlen (multi_dir);
2103       if (multi_os_dir)
2104         multi_os_dir_len = strlen (multi_os_dir);
2105       suffix_len = strlen (multi_suffix);
2106       just_suffix_len = strlen (just_multi_suffix);
2107
2108       if (path == NULL)
2109         {
2110           len = paths->max_len + extra_space + 1;
2111           if (suffix_len > multi_os_dir_len)
2112             len += suffix_len;
2113           else
2114             len += multi_os_dir_len;
2115           path = XNEWVEC (char, len);
2116         }
2117
2118       for (pl = paths->plist; pl != 0; pl = pl->next)
2119         {
2120           len = strlen (pl->prefix);
2121           memcpy (path, pl->prefix, len);
2122
2123           /* Look first in MACHINE/VERSION subdirectory.  */
2124           if (!skip_multi_dir)
2125             {
2126               memcpy (path + len, multi_suffix, suffix_len + 1);
2127               ret = callback (path, callback_info);
2128               if (ret)
2129                 break;
2130             }
2131
2132           /* Some paths are tried with just the machine (ie. target)
2133              subdir.  This is used for finding as, ld, etc.  */
2134           if (!skip_multi_dir
2135               && pl->require_machine_suffix == 2)
2136             {
2137               memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
2138               ret = callback (path, callback_info);
2139               if (ret)
2140                 break;
2141             }
2142
2143           /* Now try the base path.  */
2144           if (!pl->require_machine_suffix
2145               && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2146             {
2147               const char *this_multi;
2148               size_t this_multi_len;
2149
2150               if (pl->os_multilib)
2151                 {
2152                   this_multi = multi_os_dir;
2153                   this_multi_len = multi_os_dir_len;
2154                 }
2155               else
2156                 {
2157                   this_multi = multi_dir;
2158                   this_multi_len = multi_dir_len;
2159                 }
2160
2161               if (this_multi_len)
2162                 memcpy (path + len, this_multi, this_multi_len + 1);
2163               else
2164                 path[len] = '\0';
2165
2166               ret = callback (path, callback_info);
2167               if (ret)
2168                 break;
2169             }
2170         }
2171       if (pl)
2172         break;
2173
2174       if (multi_dir == NULL && multi_os_dir == NULL)
2175         break;
2176
2177       /* Run through the paths again, this time without multilibs.
2178          Don't repeat any we have already seen.  */
2179       if (multi_dir)
2180         {
2181           free (CONST_CAST (char *, multi_dir));
2182           multi_dir = NULL;
2183           free (CONST_CAST (char *, multi_suffix));
2184           multi_suffix = machine_suffix;
2185           free (CONST_CAST (char *, just_multi_suffix));
2186           just_multi_suffix = just_machine_suffix;
2187         }
2188       else
2189         skip_multi_dir = true;
2190       if (multi_os_dir)
2191         {
2192           free (CONST_CAST (char *, multi_os_dir));
2193           multi_os_dir = NULL;
2194         }
2195       else
2196         skip_multi_os_dir = true;
2197     }
2198
2199   if (multi_dir)
2200     {
2201       free (CONST_CAST (char *, multi_dir));
2202       free (CONST_CAST (char *, multi_suffix));
2203       free (CONST_CAST (char *, just_multi_suffix));
2204     }
2205   if (multi_os_dir)
2206     free (CONST_CAST (char *, multi_os_dir));
2207   if (ret != path)
2208     free (path);
2209   return ret;
2210 }
2211
2212 /* Callback for build_search_list.  Adds path to obstack being built.  */
2213
2214 struct add_to_obstack_info {
2215   struct obstack *ob;
2216   bool check_dir;
2217   bool first_time;
2218 };
2219
2220 static void *
2221 add_to_obstack (char *path, void *data)
2222 {
2223   struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
2224
2225   if (info->check_dir && !is_directory (path, false))
2226     return NULL;
2227
2228   if (!info->first_time)
2229     obstack_1grow (info->ob, PATH_SEPARATOR);
2230
2231   obstack_grow (info->ob, path, strlen (path));
2232
2233   info->first_time = false;
2234   return NULL;
2235 }
2236
2237 /* Add or change the value of an environment variable, outputting the
2238    change to standard error if in verbose mode.  */
2239 static void
2240 xputenv (const char *string)
2241 {
2242   if (verbose_flag)
2243     fnotice (stderr, "%s\n", string);
2244   putenv (CONST_CAST (char *, string));
2245 }
2246
2247 /* Build a list of search directories from PATHS.
2248    PREFIX is a string to prepend to the list.
2249    If CHECK_DIR_P is true we ensure the directory exists.
2250    If DO_MULTI is true, multilib paths are output first, then
2251    non-multilib paths.
2252    This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2253    It is also used by the --print-search-dirs flag.  */
2254
2255 static char *
2256 build_search_list (const struct path_prefix *paths, const char *prefix,
2257                    bool check_dir, bool do_multi)
2258 {
2259   struct add_to_obstack_info info;
2260
2261   info.ob = &collect_obstack;
2262   info.check_dir = check_dir;
2263   info.first_time = true;
2264
2265   obstack_grow (&collect_obstack, prefix, strlen (prefix));
2266   obstack_1grow (&collect_obstack, '=');
2267
2268   for_each_path (paths, do_multi, 0, add_to_obstack, &info);
2269
2270   obstack_1grow (&collect_obstack, '\0');
2271   return XOBFINISH (&collect_obstack, char *);
2272 }
2273
2274 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2275    for collect.  */
2276
2277 static void
2278 putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2279                       bool do_multi)
2280 {
2281   xputenv (build_search_list (paths, env_var, true, do_multi));
2282 }
2283 \f
2284 /* Check whether NAME can be accessed in MODE.  This is like access,
2285    except that it never considers directories to be executable.  */
2286
2287 static int
2288 access_check (const char *name, int mode)
2289 {
2290   if (mode == X_OK)
2291     {
2292       struct stat st;
2293
2294       if (stat (name, &st) < 0
2295           || S_ISDIR (st.st_mode))
2296         return -1;
2297     }
2298
2299   return access (name, mode);
2300 }
2301
2302 /* Callback for find_a_file.  Appends the file name to the directory
2303    path.  If the resulting file exists in the right mode, return the
2304    full pathname to the file.  */
2305
2306 struct file_at_path_info {
2307   const char *name;
2308   const char *suffix;
2309   int name_len;
2310   int suffix_len;
2311   int mode;
2312 };
2313
2314 static void *
2315 file_at_path (char *path, void *data)
2316 {
2317   struct file_at_path_info *info = (struct file_at_path_info *) data;
2318   size_t len = strlen (path);
2319
2320   memcpy (path + len, info->name, info->name_len);
2321   len += info->name_len;
2322
2323   /* Some systems have a suffix for executable files.
2324      So try appending that first.  */
2325   if (info->suffix_len)
2326     {
2327       memcpy (path + len, info->suffix, info->suffix_len + 1);
2328       if (access_check (path, info->mode) == 0)
2329         return path;
2330     }
2331
2332   path[len] = '\0';
2333   if (access_check (path, info->mode) == 0)
2334     return path;
2335
2336   return NULL;
2337 }
2338
2339 /* Search for NAME using the prefix list PREFIXES.  MODE is passed to
2340    access to check permissions.  If DO_MULTI is true, search multilib
2341    paths then non-multilib paths, otherwise do not search multilib paths.
2342    Return 0 if not found, otherwise return its name, allocated with malloc.  */
2343
2344 static char *
2345 find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
2346              bool do_multi)
2347 {
2348   struct file_at_path_info info;
2349
2350 #ifdef DEFAULT_ASSEMBLER
2351   if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2352     return xstrdup (DEFAULT_ASSEMBLER);
2353 #endif
2354
2355 #ifdef DEFAULT_LINKER
2356   if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2357     return xstrdup (DEFAULT_LINKER);
2358 #endif
2359
2360   /* Determine the filename to execute (special case for absolute paths).  */
2361
2362   if (IS_ABSOLUTE_PATH (name))
2363     {
2364       if (access (name, mode) == 0)
2365         return xstrdup (name);
2366
2367       return NULL;
2368     }
2369
2370   info.name = name;
2371   info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
2372   info.name_len = strlen (info.name);
2373   info.suffix_len = strlen (info.suffix);
2374   info.mode = mode;
2375
2376   return (char*) for_each_path (pprefix, do_multi,
2377                                 info.name_len + info.suffix_len,
2378                                 file_at_path, &info);
2379 }
2380
2381 /* Ranking of prefixes in the sort list. -B prefixes are put before
2382    all others.  */
2383
2384 enum path_prefix_priority
2385 {
2386   PREFIX_PRIORITY_B_OPT,
2387   PREFIX_PRIORITY_LAST
2388 };
2389
2390 /* Add an entry for PREFIX in PLIST.  The PLIST is kept in ascending
2391    order according to PRIORITY.  Within each PRIORITY, new entries are
2392    appended.
2393
2394    If WARN is nonzero, we will warn if no file is found
2395    through this prefix.  WARN should point to an int
2396    which will be set to 1 if this entry is used.
2397
2398    COMPONENT is the value to be passed to update_path.
2399
2400    REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2401    the complete value of machine_suffix.
2402    2 means try both machine_suffix and just_machine_suffix.  */
2403
2404 static void
2405 add_prefix (struct path_prefix *pprefix, const char *prefix,
2406             const char *component, /* enum prefix_priority */ int priority,
2407             int require_machine_suffix, int os_multilib)
2408 {
2409   struct prefix_list *pl, **prev;
2410   int len;
2411
2412   for (prev = &pprefix->plist;
2413        (*prev) != NULL && (*prev)->priority <= priority;
2414        prev = &(*prev)->next)
2415     ;
2416
2417   /* Keep track of the longest prefix.  */
2418
2419   prefix = update_path (prefix, component);
2420   len = strlen (prefix);
2421   if (len > pprefix->max_len)
2422     pprefix->max_len = len;
2423
2424   pl = XNEW (struct prefix_list);
2425   pl->prefix = prefix;
2426   pl->require_machine_suffix = require_machine_suffix;
2427   pl->priority = priority;
2428   pl->os_multilib = os_multilib;
2429
2430   /* Insert after PREV.  */
2431   pl->next = (*prev);
2432   (*prev) = pl;
2433 }
2434
2435 /* Same as add_prefix, but prepending target_system_root to prefix.  */
2436 /* The target_system_root prefix has been relocated by gcc_exec_prefix.  */
2437 static void
2438 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2439                       const char *component,
2440                       /* enum prefix_priority */ int priority,
2441                       int require_machine_suffix, int os_multilib)
2442 {
2443   if (!IS_ABSOLUTE_PATH (prefix))
2444     fatal_error ("system path %qs is not absolute", prefix);
2445
2446   if (target_system_root)
2447     {
2448       char *sysroot_no_trailing_dir_separator = xstrdup (target_system_root);
2449       size_t sysroot_len = strlen (target_system_root);
2450
2451       if (sysroot_len > 0
2452           && target_system_root[sysroot_len - 1] == DIR_SEPARATOR)
2453         sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0';
2454
2455       if (target_sysroot_suffix)
2456           prefix = concat (target_sysroot_suffix, prefix, NULL);
2457       prefix = concat (sysroot_no_trailing_dir_separator, prefix, NULL);
2458       free (sysroot_no_trailing_dir_separator);
2459
2460       /* We have to override this because GCC's notion of sysroot
2461          moves along with GCC.  */
2462       component = "GCC";
2463     }
2464
2465   add_prefix (pprefix, prefix, component, priority,
2466               require_machine_suffix, os_multilib);
2467 }
2468 \f
2469 /* Execute the command specified by the arguments on the current line of spec.
2470    When using pipes, this includes several piped-together commands
2471    with `|' between them.
2472
2473    Return 0 if successful, -1 if failed.  */
2474
2475 static int
2476 execute (void)
2477 {
2478   int i;
2479   int n_commands;               /* # of command.  */
2480   char *string;
2481   struct pex_obj *pex;
2482   struct command
2483   {
2484     const char *prog;           /* program name.  */
2485     const char **argv;          /* vector of args.  */
2486   };
2487   const char *arg;
2488
2489   struct command *commands;     /* each command buffer with above info.  */
2490
2491   gcc_assert (!processing_spec_function);
2492
2493   if (wrapper_string)
2494     {
2495       string = find_a_file (&exec_prefixes,
2496                             VEC_index (const_char_p, argbuf, 0), X_OK, false);
2497       if (string)
2498         VEC_replace (const_char_p, argbuf, 0, string);
2499       insert_wrapper (wrapper_string);
2500     }
2501
2502   /* Count # of piped commands.  */
2503   for (n_commands = 1, i = 0; VEC_iterate (const_char_p, argbuf, i, arg); i++)
2504     if (strcmp (arg, "|") == 0)
2505       n_commands++;
2506
2507   /* Get storage for each command.  */
2508   commands = (struct command *) alloca (n_commands * sizeof (struct command));
2509
2510   /* Split argbuf into its separate piped processes,
2511      and record info about each one.
2512      Also search for the programs that are to be run.  */
2513
2514   VEC_safe_push (const_char_p, heap, argbuf, 0);
2515
2516   commands[0].prog = VEC_index (const_char_p, argbuf, 0); /* first command.  */
2517   commands[0].argv = VEC_address (const_char_p, argbuf);
2518
2519   if (!wrapper_string)
2520     {
2521       string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
2522       commands[0].argv[0] = (string) ? string : commands[0].argv[0];
2523     }
2524
2525   for (n_commands = 1, i = 0; VEC_iterate (const_char_p, argbuf, i, arg); i++)
2526     if (arg && strcmp (arg, "|") == 0)
2527       {                         /* each command.  */
2528 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2529         fatal_error ("-pipe not supported");
2530 #endif
2531         VEC_replace (const_char_p, argbuf, i, 0); /* Termination of
2532                                                      command args.  */
2533         commands[n_commands].prog = VEC_index (const_char_p, argbuf, i + 1);
2534         commands[n_commands].argv
2535           = &(VEC_address (const_char_p, argbuf))[i + 1];
2536         string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2537                               X_OK, false);
2538         if (string)
2539           commands[n_commands].argv[0] = string;
2540         n_commands++;
2541       }
2542
2543   /* If -v, print what we are about to do, and maybe query.  */
2544
2545   if (verbose_flag)
2546     {
2547       /* For help listings, put a blank line between sub-processes.  */
2548       if (print_help_list)
2549         fputc ('\n', stderr);
2550
2551       /* Print each piped command as a separate line.  */
2552       for (i = 0; i < n_commands; i++)
2553         {
2554           const char *const *j;
2555
2556           if (verbose_only_flag)
2557             {
2558               for (j = commands[i].argv; *j; j++)
2559                 {
2560                   const char *p;
2561                   for (p = *j; *p; ++p)
2562                     if (!ISALNUM ((unsigned char) *p)
2563                         && *p != '_' && *p != '/' && *p != '-' && *p != '.')
2564                       break;
2565                   if (*p || !*j)
2566                     {
2567                       fprintf (stderr, " \"");
2568                       for (p = *j; *p; ++p)
2569                         {
2570                           if (*p == '"' || *p == '\\' || *p == '$')
2571                             fputc ('\\', stderr);
2572                           fputc (*p, stderr);
2573                         }
2574                       fputc ('"', stderr);
2575                     }
2576                   /* If it's empty, print "".  */
2577                   else if (!**j)
2578                     fprintf (stderr, " \"\"");
2579                   else
2580                     fprintf (stderr, " %s", *j);
2581                 }
2582             }
2583           else
2584             for (j = commands[i].argv; *j; j++)
2585               /* If it's empty, print "".  */
2586               if (!**j)
2587                 fprintf (stderr, " \"\"");
2588               else
2589                 fprintf (stderr, " %s", *j);
2590
2591           /* Print a pipe symbol after all but the last command.  */
2592           if (i + 1 != n_commands)
2593             fprintf (stderr, " |");
2594           fprintf (stderr, "\n");
2595         }
2596       fflush (stderr);
2597       if (verbose_only_flag != 0)
2598         {
2599           /* verbose_only_flag should act as if the spec was
2600              executed, so increment execution_count before
2601              returning.  This prevents spurious warnings about
2602              unused linker input files, etc.  */
2603           execution_count++;
2604           return 0;
2605         }
2606 #ifdef DEBUG
2607       fnotice (stderr, "\nGo ahead? (y or n) ");
2608       fflush (stderr);
2609       i = getchar ();
2610       if (i != '\n')
2611         while (getchar () != '\n')
2612           ;
2613
2614       if (i != 'y' && i != 'Y')
2615         return 0;
2616 #endif /* DEBUG */
2617     }
2618
2619 #ifdef ENABLE_VALGRIND_CHECKING
2620   /* Run the each command through valgrind.  To simplify prepending the
2621      path to valgrind and the option "-q" (for quiet operation unless
2622      something triggers), we allocate a separate argv array.  */
2623
2624   for (i = 0; i < n_commands; i++)
2625     {
2626       const char **argv;
2627       int argc;
2628       int j;
2629
2630       for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2631         ;
2632
2633       argv = XALLOCAVEC (const char *, argc + 3);
2634
2635       argv[0] = VALGRIND_PATH;
2636       argv[1] = "-q";
2637       for (j = 2; j < argc + 2; j++)
2638         argv[j] = commands[i].argv[j - 2];
2639       argv[j] = NULL;
2640
2641       commands[i].argv = argv;
2642       commands[i].prog = argv[0];
2643     }
2644 #endif
2645
2646   /* Run each piped subprocess.  */
2647
2648   pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
2649                                    ? PEX_RECORD_TIMES : 0),
2650                   progname, temp_filename);
2651   if (pex == NULL)
2652     fatal_error ("pex_init failed: %m");
2653
2654   for (i = 0; i < n_commands; i++)
2655     {
2656       const char *errmsg;
2657       int err;
2658       const char *string = commands[i].argv[0];
2659
2660       errmsg = pex_run (pex,
2661                         ((i + 1 == n_commands ? PEX_LAST : 0)
2662                          | (string == commands[i].prog ? PEX_SEARCH : 0)),
2663                         string, CONST_CAST (char **, commands[i].argv),
2664                         NULL, NULL, &err);
2665       if (errmsg != NULL)
2666         {
2667           if (err == 0)
2668             fatal_error (errmsg);
2669           else
2670             {
2671               errno = err;
2672               pfatal_with_name (errmsg);
2673             }
2674         }
2675
2676       if (string != commands[i].prog)
2677         free (CONST_CAST (char *, string));
2678     }
2679
2680   execution_count++;
2681
2682   /* Wait for all the subprocesses to finish.  */
2683
2684   {
2685     int *statuses;
2686     struct pex_time *times = NULL;
2687     int ret_code = 0;
2688
2689     statuses = (int *) alloca (n_commands * sizeof (int));
2690     if (!pex_get_status (pex, n_commands, statuses))
2691       fatal_error ("failed to get exit status: %m");
2692
2693     if (report_times || report_times_to_file)
2694       {
2695         times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
2696         if (!pex_get_times (pex, n_commands, times))
2697           fatal_error ("failed to get process times: %m");
2698       }
2699
2700     pex_free (pex);
2701
2702     for (i = 0; i < n_commands; ++i)
2703       {
2704         int status = statuses[i];
2705
2706         if (WIFSIGNALED (status))
2707           {
2708 #ifdef SIGPIPE
2709             /* SIGPIPE is a special case.  It happens in -pipe mode
2710                when the compiler dies before the preprocessor is done,
2711                or the assembler dies before the compiler is done.
2712                There's generally been an error already, and this is
2713                just fallout.  So don't generate another error unless
2714                we would otherwise have succeeded.  */
2715             if (WTERMSIG (status) == SIGPIPE
2716                 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2717               {
2718                 signal_count++;
2719                 ret_code = -1;
2720               }
2721             else
2722 #endif
2723               internal_error ("%s (program %s)",
2724                               strsignal (WTERMSIG (status)), commands[i].prog);
2725           }
2726         else if (WIFEXITED (status)
2727                  && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2728           {
2729             if (WEXITSTATUS (status) > greatest_status)
2730               greatest_status = WEXITSTATUS (status);
2731             ret_code = -1;
2732           }
2733
2734         if (report_times || report_times_to_file)
2735           {
2736             struct pex_time *pt = &times[i];
2737             double ut, st;
2738
2739             ut = ((double) pt->user_seconds
2740                   + (double) pt->user_microseconds / 1.0e6);
2741             st = ((double) pt->system_seconds
2742                   + (double) pt->system_microseconds / 1.0e6);
2743
2744             if (ut + st != 0)
2745               {
2746                 if (report_times)
2747                   fnotice (stderr, "# %s %.2f %.2f\n",
2748                            commands[i].prog, ut, st);
2749
2750                 if (report_times_to_file)
2751                   {
2752                     int c = 0;
2753                     const char *const *j;
2754
2755                     fprintf (report_times_to_file, "%g %g", ut, st);
2756
2757                     for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
2758                       {
2759                         const char *p;
2760                         for (p = *j; *p; ++p)
2761                           if (*p == '"' || *p == '\\' || *p == '$'
2762                               || ISSPACE (*p))
2763                             break;
2764
2765                         if (*p)
2766                           {
2767                             fprintf (report_times_to_file, " \"");
2768                             for (p = *j; *p; ++p)
2769                               {
2770                                 if (*p == '"' || *p == '\\' || *p == '$')
2771                                   fputc ('\\', report_times_to_file);
2772                                 fputc (*p, report_times_to_file);
2773                               }
2774                             fputc ('"', report_times_to_file);
2775                           }
2776                         else
2777                           fprintf (report_times_to_file, " %s", *j);
2778                       }
2779
2780                     fputc ('\n', report_times_to_file);
2781                   }
2782               }
2783           }
2784       }
2785
2786     return ret_code;
2787   }
2788 }
2789 \f
2790 /* Find all the switches given to us
2791    and make a vector describing them.
2792    The elements of the vector are strings, one per switch given.
2793    If a switch uses following arguments, then the `part1' field
2794    is the switch itself and the `args' field
2795    is a null-terminated vector containing the following arguments.
2796    Bits in the `live_cond' field are:
2797    SWITCH_LIVE to indicate this switch is true in a conditional spec.
2798    SWITCH_FALSE to indicate this switch is overridden by a later switch.
2799    SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
2800    SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
2801    in all do_spec calls afterwards.  Used for %<S from self specs.
2802    The `validated' field is nonzero if any spec has looked at this switch;
2803    if it remains zero at the end of the run, it must be meaningless.  */
2804
2805 #define SWITCH_LIVE                     (1 << 0)
2806 #define SWITCH_FALSE                    (1 << 1)
2807 #define SWITCH_IGNORE                   (1 << 2)
2808 #define SWITCH_IGNORE_PERMANENTLY       (1 << 3)
2809 #define SWITCH_KEEP_FOR_GCC             (1 << 4)
2810
2811 struct switchstr
2812 {
2813   const char *part1;
2814   const char **args;
2815   unsigned int live_cond;
2816   unsigned char validated;
2817   unsigned char ordering;
2818 };
2819
2820 static struct switchstr *switches;
2821
2822 static int n_switches;
2823
2824 static int n_switches_alloc;
2825
2826 /* Set to zero if -fcompare-debug is disabled, positive if it's
2827    enabled and we're running the first compilation, negative if it's
2828    enabled and we're running the second compilation.  For most of the
2829    time, it's in the range -1..1, but it can be temporarily set to 2
2830    or 3 to indicate that the -fcompare-debug flags didn't come from
2831    the command-line, but rather from the GCC_COMPARE_DEBUG environment
2832    variable, until a synthesized -fcompare-debug flag is added to the
2833    command line.  */
2834 int compare_debug;
2835
2836 /* Set to nonzero if we've seen the -fcompare-debug-second flag.  */
2837 int compare_debug_second;
2838
2839 /* Set to the flags that should be passed to the second compilation in
2840    a -fcompare-debug compilation.  */
2841 const char *compare_debug_opt;
2842
2843 static struct switchstr *switches_debug_check[2];
2844
2845 static int n_switches_debug_check[2];
2846
2847 static int n_switches_alloc_debug_check[2];
2848
2849 static char *debug_check_temp_file[2];
2850
2851 /* Language is one of three things:
2852
2853    1) The name of a real programming language.
2854    2) NULL, indicating that no one has figured out
2855    what it is yet.
2856    3) '*', indicating that the file should be passed
2857    to the linker.  */
2858 struct infile
2859 {
2860   const char *name;
2861   const char *language;
2862   struct compiler *incompiler;
2863   bool compiled;
2864   bool preprocessed;
2865 };
2866
2867 /* Also a vector of input files specified.  */
2868
2869 static struct infile *infiles;
2870
2871 int n_infiles;
2872
2873 static int n_infiles_alloc;
2874
2875 /* True if multiple input files are being compiled to a single
2876    assembly file.  */
2877
2878 static bool combine_inputs;
2879
2880 /* This counts the number of libraries added by lang_specific_driver, so that
2881    we can tell if there were any user supplied any files or libraries.  */
2882
2883 static int added_libraries;
2884
2885 /* And a vector of corresponding output files is made up later.  */
2886
2887 const char **outfiles;
2888 \f
2889 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2890
2891 /* Convert NAME to a new name if it is the standard suffix.  DO_EXE
2892    is true if we should look for an executable suffix.  DO_OBJ
2893    is true if we should look for an object suffix.  */
2894
2895 static const char *
2896 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
2897                   int do_obj ATTRIBUTE_UNUSED)
2898 {
2899 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2900   int i;
2901 #endif
2902   int len;
2903
2904   if (name == NULL)
2905     return NULL;
2906
2907   len = strlen (name);
2908
2909 #ifdef HAVE_TARGET_OBJECT_SUFFIX
2910   /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj".  */
2911   if (do_obj && len > 2
2912       && name[len - 2] == '.'
2913       && name[len - 1] == 'o')
2914     {
2915       obstack_grow (&obstack, name, len - 2);
2916       obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
2917       name = XOBFINISH (&obstack, const char *);
2918     }
2919 #endif
2920
2921 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2922   /* If there is no filetype, make it the executable suffix (which includes
2923      the ".").  But don't get confused if we have just "-o".  */
2924   if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
2925     return name;
2926
2927   for (i = len - 1; i >= 0; i--)
2928     if (IS_DIR_SEPARATOR (name[i]))
2929       break;
2930
2931   for (i++; i < len; i++)
2932     if (name[i] == '.')
2933       return name;
2934
2935   obstack_grow (&obstack, name, len);
2936   obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
2937                  strlen (TARGET_EXECUTABLE_SUFFIX));
2938   name = XOBFINISH (&obstack, const char *);
2939 #endif
2940
2941   return name;
2942 }
2943 #endif
2944 \f
2945 /* Display the command line switches accepted by gcc.  */
2946 static void
2947 display_help (void)
2948 {
2949   printf (_("Usage: %s [options] file...\n"), progname);
2950   fputs (_("Options:\n"), stdout);
2951
2952   fputs (_("  -pass-exit-codes         Exit with highest error code from a phase\n"), stdout);
2953   fputs (_("  --help                   Display this information\n"), stdout);
2954   fputs (_("  --target-help            Display target specific command line options\n"), stdout);
2955   fputs (_("  --help={target|optimizers|warnings|params|[^]{joined|separate|undocumented}}[,...]\n"), stdout);
2956   fputs (_("                           Display specific types of command line options\n"), stdout);
2957   if (! verbose_flag)
2958     fputs (_("  (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
2959   fputs (_("  --version                Display compiler version information\n"), stdout);
2960   fputs (_("  -dumpspecs               Display all of the built in spec strings\n"), stdout);
2961   fputs (_("  -dumpversion             Display the version of the compiler\n"), stdout);
2962   fputs (_("  -dumpmachine             Display the compiler's target processor\n"), stdout);
2963   fputs (_("  -print-search-dirs       Display the directories in the compiler's search path\n"), stdout);
2964   fputs (_("  -print-libgcc-file-name  Display the name of the compiler's companion library\n"), stdout);
2965   fputs (_("  -print-file-name=<lib>   Display the full path to library <lib>\n"), stdout);
2966   fputs (_("  -print-prog-name=<prog>  Display the full path to compiler component <prog>\n"), stdout);
2967   fputs (_("  -print-multi-directory   Display the root directory for versions of libgcc\n"), stdout);
2968   fputs (_("\
2969   -print-multi-lib         Display the mapping between command line options and\n\
2970                            multiple library search directories\n"), stdout);
2971   fputs (_("  -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
2972   fputs (_("  -print-sysroot           Display the target libraries directory\n"), stdout);
2973   fputs (_("  -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout);
2974   fputs (_("  -Wa,<options>            Pass comma-separated <options> on to the assembler\n"), stdout);
2975   fputs (_("  -Wp,<options>            Pass comma-separated <options> on to the preprocessor\n"), stdout);
2976   fputs (_("  -Wl,<options>            Pass comma-separated <options> on to the linker\n"), stdout);
2977   fputs (_("  -Xassembler <arg>        Pass <arg> on to the assembler\n"), stdout);
2978   fputs (_("  -Xpreprocessor <arg>     Pass <arg> on to the preprocessor\n"), stdout);
2979   fputs (_("  -Xlinker <arg>           Pass <arg> on to the linker\n"), stdout);
2980   fputs (_("  -save-temps              Do not delete intermediate files\n"), stdout);
2981   fputs (_("  -save-temps=<arg>        Do not delete intermediate files\n"), stdout);
2982   fputs (_("\
2983   -no-canonical-prefixes   Do not canonicalize paths when building relative\n\
2984                            prefixes to other gcc components\n"), stdout);
2985   fputs (_("  -pipe                    Use pipes rather than intermediate files\n"), stdout);
2986   fputs (_("  -time                    Time the execution of each subprocess\n"), stdout);
2987   fputs (_("  -specs=<file>            Override built-in specs with the contents of <file>\n"), stdout);
2988   fputs (_("  -std=<standard>          Assume that the input sources are for <standard>\n"), stdout);
2989   fputs (_("\
2990   --sysroot=<directory>    Use <directory> as the root directory for headers\n\
2991                            and libraries\n"), stdout);
2992   fputs (_("  -B <directory>           Add <directory> to the compiler's search paths\n"), stdout);
2993   fputs (_("  -v                       Display the programs invoked by the compiler\n"), stdout);
2994   fputs (_("  -###                     Like -v but options quoted and commands not executed\n"), stdout);
2995   fputs (_("  -E                       Preprocess only; do not compile, assemble or link\n"), stdout);
2996   fputs (_("  -S                       Compile only; do not assemble or link\n"), stdout);
2997   fputs (_("  -c                       Compile and assemble, but do not link\n"), stdout);
2998   fputs (_("  -o <file>                Place the output into <file>\n"), stdout);
2999   fputs (_("  -pie                     Create a position independent executable\n"), stdout);
3000   fputs (_("  -shared                  Create a shared library\n"), stdout);
3001   fputs (_("\
3002   -x <language>            Specify the language of the following input files\n\
3003                            Permissible languages include: c c++ assembler none\n\
3004                            'none' means revert to the default behavior of\n\
3005                            guessing the language based on the file's extension\n\
3006 "), stdout);
3007
3008   printf (_("\
3009 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3010  passed on to the various sub-processes invoked by %s.  In order to pass\n\
3011  other options on to these processes the -W<letter> options must be used.\n\
3012 "), progname);
3013
3014   /* The rest of the options are displayed by invocations of the various
3015      sub-processes.  */
3016 }
3017
3018 static void
3019 add_preprocessor_option (const char *option, int len)
3020 {
3021   VEC_safe_push (char_p, heap, preprocessor_options,
3022                  save_string (option, len));
3023 }
3024
3025 static void
3026 add_assembler_option (const char *option, int len)
3027 {
3028   VEC_safe_push (char_p, heap, assembler_options, save_string (option, len));
3029 }
3030
3031 static void
3032 add_linker_option (const char *option, int len)
3033 {
3034   VEC_safe_push (char_p, heap, linker_options, save_string (option, len));
3035 }
3036 \f
3037 /* Allocate space for an input file in infiles.  */
3038
3039 static void
3040 alloc_infile (void)
3041 {
3042   if (n_infiles_alloc == 0)
3043     {
3044       n_infiles_alloc = 16;
3045       infiles = XNEWVEC (struct infile, n_infiles_alloc);
3046     }
3047   else if (n_infiles_alloc == n_infiles)
3048     {
3049       n_infiles_alloc *= 2;
3050       infiles = XRESIZEVEC (struct infile, infiles, n_infiles_alloc);
3051     }
3052 }
3053
3054 /* Store an input file with the given NAME and LANGUAGE in
3055    infiles.  */
3056
3057 static void
3058 add_infile (const char *name, const char *language)
3059 {
3060   alloc_infile ();
3061   infiles[n_infiles].name = name;
3062   infiles[n_infiles++].language = language;
3063 }
3064
3065 /* Allocate space for a switch in switches.  */
3066
3067 static void
3068 alloc_switch (void)
3069 {
3070   if (n_switches_alloc == 0)
3071     {
3072       n_switches_alloc = 16;
3073       switches = XNEWVEC (struct switchstr, n_switches_alloc);
3074     }
3075   else if (n_switches_alloc == n_switches)
3076     {
3077       n_switches_alloc *= 2;
3078       switches = XRESIZEVEC (struct switchstr, switches, n_switches_alloc);
3079     }
3080 }
3081
3082 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3083    as validated if VALIDATED.  */
3084
3085 static void
3086 save_switch (const char *opt, size_t n_args, const char *const *args,
3087              bool validated)
3088 {
3089   alloc_switch ();
3090   switches[n_switches].part1 = opt + 1;
3091   if (n_args == 0)
3092     switches[n_switches].args = 0;
3093   else
3094     {
3095       switches[n_switches].args = XNEWVEC (const char *, n_args + 1);
3096       memcpy (switches[n_switches].args, args, n_args * sizeof (const char *));
3097       switches[n_switches].args[n_args] = NULL;
3098     }
3099
3100   switches[n_switches].live_cond = 0;
3101   switches[n_switches].validated = validated;
3102   switches[n_switches].ordering = 0;
3103   n_switches++;
3104 }
3105
3106 /* Handle an option DECODED that is unknown to the option-processing
3107    machinery.  */
3108
3109 static bool
3110 driver_unknown_option_callback (const struct cl_decoded_option *decoded)
3111 {
3112   const char *opt = decoded->arg;
3113   if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
3114       && !(decoded->errors & CL_ERR_NEGATIVE))
3115     {
3116       /* Leave unknown -Wno-* options for the compiler proper, to be
3117          diagnosed only if there are warnings.  */
3118       save_switch (decoded->canonical_option[0],
3119                    decoded->canonical_option_num_elements - 1,
3120                    &decoded->canonical_option[1], false);
3121       return false;
3122     }
3123   else
3124     return true;
3125 }
3126
3127 /* Handle an option DECODED that is not marked as CL_DRIVER.
3128    LANG_MASK will always be CL_DRIVER.  */
3129
3130 static void
3131 driver_wrong_lang_callback (const struct cl_decoded_option *decoded,
3132                             unsigned int lang_mask ATTRIBUTE_UNUSED)
3133 {
3134   /* At this point, non-driver options are accepted (and expected to
3135      be passed down by specs) unless marked to be rejected by the
3136      driver.  Options to be rejected by the driver but accepted by the
3137      compilers proper are treated just like completely unknown
3138      options.  */
3139   const struct cl_option *option = &cl_options[decoded->opt_index];
3140
3141   if (option->cl_reject_driver)
3142     error ("unrecognized command line option %qs",
3143            decoded->orig_option_with_args_text);
3144   else
3145     save_switch (decoded->canonical_option[0],
3146                  decoded->canonical_option_num_elements - 1,
3147                  &decoded->canonical_option[1], false);
3148 }
3149
3150 static const char *spec_lang = 0;
3151 static int last_language_n_infiles;
3152
3153 /* Handle a driver option; arguments and return value as for
3154    handle_option.  */
3155
3156 static bool
3157 driver_handle_option (struct gcc_options *opts,
3158                       struct gcc_options *opts_set,
3159                       const struct cl_decoded_option *decoded,
3160                       unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
3161                       location_t loc,
3162                       const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
3163                       diagnostic_context *dc)
3164 {
3165   size_t opt_index = decoded->opt_index;
3166   const char *arg = decoded->arg;
3167   const char *compare_debug_replacement_opt;
3168   int value = decoded->value;
3169   bool validated = false;
3170   bool do_save = true;
3171
3172   gcc_assert (opts == &global_options);
3173   gcc_assert (opts_set == &global_options_set);
3174   gcc_assert (kind == DK_UNSPECIFIED);
3175   gcc_assert (loc == UNKNOWN_LOCATION);
3176   gcc_assert (dc == global_dc);
3177
3178   switch (opt_index)
3179     {
3180     case OPT_dumpspecs:
3181       {
3182         struct spec_list *sl;
3183         init_spec ();
3184         for (sl = specs; sl; sl = sl->next)
3185           printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3186         if (link_command_spec)
3187           printf ("*link_command:\n%s\n\n", link_command_spec);
3188         exit (0);
3189       }
3190
3191     case OPT_dumpversion:
3192       printf ("%s\n", spec_version);
3193       exit (0);
3194
3195     case OPT_dumpmachine:
3196       printf ("%s\n", spec_machine);
3197       exit (0);
3198
3199     case OPT__version:
3200       print_version = 1;
3201
3202       /* CPP driver cannot obtain switch from cc1_options.  */
3203       if (is_cpp_driver)
3204         add_preprocessor_option ("--version", strlen ("--version"));
3205       add_assembler_option ("--version", strlen ("--version"));
3206       add_linker_option ("--version", strlen ("--version"));
3207       break;
3208
3209     case OPT__help:
3210       print_help_list = 1;
3211
3212       /* CPP driver cannot obtain switch from cc1_options.  */
3213       if (is_cpp_driver)
3214         add_preprocessor_option ("--help", 6);
3215       add_assembler_option ("--help", 6);
3216       add_linker_option ("--help", 6);
3217       break;
3218
3219     case OPT__help_:
3220       print_subprocess_help = 2;
3221       break;
3222
3223     case OPT__target_help:
3224       print_subprocess_help = 1;
3225
3226       /* CPP driver cannot obtain switch from cc1_options.  */
3227       if (is_cpp_driver)
3228         add_preprocessor_option ("--target-help", 13);
3229       add_assembler_option ("--target-help", 13);
3230       add_linker_option ("--target-help", 13);
3231       break;
3232
3233     case OPT_pass_exit_codes:
3234     case OPT_print_search_dirs:
3235     case OPT_print_file_name_:
3236     case OPT_print_prog_name_:
3237     case OPT_print_multi_lib:
3238     case OPT_print_multi_directory:
3239     case OPT_print_sysroot:
3240     case OPT_print_multi_os_directory:
3241     case OPT_print_sysroot_headers_suffix:
3242     case OPT_time:
3243     case OPT_wrapper:
3244       /* These options set the variables specified in common.opt
3245          automatically, and do not need to be saved for spec
3246          processing.  */
3247       do_save = false;
3248       break;
3249
3250     case OPT_print_libgcc_file_name:
3251       print_file_name = "libgcc.a";
3252       do_save = false;
3253       break;
3254
3255     case OPT_fcompare_debug_second:
3256       compare_debug_second = 1;
3257       break;
3258
3259     case OPT_fcompare_debug:
3260       switch (value)
3261         {
3262         case 0:
3263           compare_debug_replacement_opt = "-fcompare-debug=";
3264           arg = "";
3265           goto compare_debug_with_arg;
3266
3267         case 1:
3268           compare_debug_replacement_opt = "-fcompare-debug=-gtoggle";
3269           arg = "-gtoggle";
3270           goto compare_debug_with_arg;
3271
3272         default:
3273           gcc_unreachable ();
3274         }
3275       break;
3276
3277     case OPT_fcompare_debug_:
3278       compare_debug_replacement_opt = decoded->canonical_option[0];
3279     compare_debug_with_arg:
3280       gcc_assert (decoded->canonical_option_num_elements == 1);
3281       gcc_assert (arg != NULL);
3282       if (*arg)
3283         compare_debug = 1;
3284       else
3285         compare_debug = -1;
3286       if (compare_debug < 0)
3287         compare_debug_opt = NULL;
3288       else
3289         compare_debug_opt = arg;
3290       save_switch (compare_debug_replacement_opt, 0, NULL, validated);
3291       return true;
3292
3293     case OPT_Wa_:
3294       {
3295         int prev, j;
3296         /* Pass the rest of this option to the assembler.  */
3297
3298         /* Split the argument at commas.  */
3299         prev = 0;
3300         for (j = 0; arg[j]; j++)
3301           if (arg[j] == ',')
3302             {
3303               add_assembler_option (arg + prev, j - prev);
3304               prev = j + 1;
3305             }
3306
3307         /* Record the part after the last comma.  */
3308         add_assembler_option (arg + prev, j - prev);
3309       }
3310       do_save = false;
3311       break;
3312
3313     case OPT_Wp_:
3314       {
3315         int prev, j;
3316         /* Pass the rest of this option to the preprocessor.  */
3317
3318         /* Split the argument at commas.  */
3319         prev = 0;
3320         for (j = 0; arg[j]; j++)
3321           if (arg[j] == ',')
3322             {
3323               add_preprocessor_option (arg + prev, j - prev);
3324               prev = j + 1;
3325             }
3326
3327         /* Record the part after the last comma.  */
3328         add_preprocessor_option (arg + prev, j - prev);
3329       }
3330       do_save = false;
3331       break;
3332
3333     case OPT_Wl_:
3334       {
3335         int prev, j;
3336         /* Split the argument at commas.  */
3337         prev = 0;
3338         for (j = 0; arg[j]; j++)
3339           if (arg[j] == ',')
3340             {
3341               add_infile (save_string (arg + prev, j - prev), "*");
3342               prev = j + 1;
3343             }
3344         /* Record the part after the last comma.  */
3345         add_infile (arg + prev, "*");
3346       }
3347       do_save = false;
3348       break;
3349
3350     case OPT_Xlinker:
3351       add_infile (arg, "*");
3352       do_save = false;
3353       break;
3354
3355     case OPT_Xpreprocessor:
3356       add_preprocessor_option (arg, strlen (arg));
3357       do_save = false;
3358       break;
3359
3360     case OPT_Xassembler:
3361       add_assembler_option (arg, strlen (arg));
3362       do_save = false;
3363       break;
3364
3365     case OPT_l:
3366       /* POSIX allows separation of -l and the lib arg; canonicalize
3367          by concatenating -l with its arg */
3368       add_infile (concat ("-l", arg, NULL), "*");
3369       do_save = false;
3370       break;
3371
3372     case OPT_L:
3373       /* Similarly, canonicalize -L for linkers that may not accept
3374          separate arguments.  */
3375       save_switch (concat ("-L", arg, NULL), 0, NULL, validated);
3376       return true;
3377
3378     case OPT_F:
3379       /* Likewise -F.  */
3380       save_switch (concat ("-F", arg, NULL), 0, NULL, validated);
3381       return true;
3382
3383     case OPT_save_temps:
3384       save_temps_flag = SAVE_TEMPS_CWD;
3385       validated = true;
3386       break;
3387
3388     case OPT_save_temps_:
3389       if (strcmp (arg, "cwd") == 0)
3390         save_temps_flag = SAVE_TEMPS_CWD;
3391       else if (strcmp (arg, "obj") == 0
3392                || strcmp (arg, "object") == 0)
3393         save_temps_flag = SAVE_TEMPS_OBJ;
3394       else
3395         fatal_error ("%qs is an unknown -save-temps option",
3396                      decoded->orig_option_with_args_text);
3397       break;
3398
3399     case OPT_no_canonical_prefixes:
3400       /* Already handled as a special case, so ignored here.  */
3401       do_save = false;
3402       break;
3403
3404     case OPT_pipe:
3405       validated = true;
3406       /* These options set the variables specified in common.opt
3407          automatically, but do need to be saved for spec
3408          processing.  */
3409       break;
3410
3411     case OPT_specs_:
3412       {
3413         struct user_specs *user = XNEW (struct user_specs);
3414
3415         user->next = (struct user_specs *) 0;
3416         user->filename = arg;
3417         if (user_specs_tail)
3418           user_specs_tail->next = user;
3419         else
3420           user_specs_head = user;
3421         user_specs_tail = user;
3422       }
3423       do_save = false;
3424       break;
3425
3426     case OPT__sysroot_:
3427       target_system_root = arg;
3428       target_system_root_changed = 1;
3429       do_save = false;
3430       break;
3431
3432     case OPT_time_:
3433       if (report_times_to_file)
3434         fclose (report_times_to_file);
3435       report_times_to_file = fopen (arg, "a");
3436       do_save = false;
3437       break;
3438
3439     case OPT____:
3440       /* "-###"
3441          This is similar to -v except that there is no execution
3442          of the commands and the echoed arguments are quoted.  It
3443          is intended for use in shell scripts to capture the
3444          driver-generated command line.  */
3445       verbose_only_flag++;
3446       verbose_flag = 1;
3447       do_save = false;
3448       break;
3449
3450     case OPT_B:
3451       {
3452         size_t len = strlen (arg);
3453
3454         /* Catch the case where the user has forgotten to append a
3455            directory separator to the path.  Note, they may be using
3456            -B to add an executable name prefix, eg "i386-elf-", in
3457            order to distinguish between multiple installations of
3458            GCC in the same directory.  Hence we must check to see
3459            if appending a directory separator actually makes a
3460            valid directory name.  */
3461         if (!IS_DIR_SEPARATOR (arg[len - 1])
3462             && is_directory (arg, false))
3463           {
3464             char *tmp = XNEWVEC (char, len + 2);
3465             strcpy (tmp, arg);
3466             tmp[len] = DIR_SEPARATOR;
3467             tmp[++len] = 0;
3468             arg = tmp;
3469           }
3470
3471         add_prefix (&exec_prefixes, arg, NULL,
3472                     PREFIX_PRIORITY_B_OPT, 0, 0);
3473         add_prefix (&startfile_prefixes, arg, NULL,
3474                     PREFIX_PRIORITY_B_OPT, 0, 0);
3475         add_prefix (&include_prefixes, arg, NULL,
3476                     PREFIX_PRIORITY_B_OPT, 0, 0);
3477       }
3478       validated = true;
3479       break;
3480
3481     case OPT_x:
3482       spec_lang = arg;
3483       if (!strcmp (spec_lang, "none"))
3484         /* Suppress the warning if -xnone comes after the last input
3485            file, because alternate command interfaces like g++ might
3486            find it useful to place -xnone after each input file.  */
3487         spec_lang = 0;
3488       else
3489         last_language_n_infiles = n_infiles;
3490       do_save = false;
3491       break;
3492
3493     case OPT_o:
3494       have_o = 1;
3495 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3496       arg = convert_filename (arg, ! have_c, 0);
3497 #endif
3498       /* Save the output name in case -save-temps=obj was used.  */
3499       save_temps_prefix = xstrdup (arg);
3500       /* On some systems, ld cannot handle "-o" without a space.  So
3501          split the option from its argument.  */
3502       save_switch ("-o", 1, &arg, validated);
3503       return true;
3504
3505     case OPT_static_libgcc:
3506     case OPT_shared_libgcc:
3507     case OPT_static_libgfortran:
3508     case OPT_static_libstdc__:
3509       /* These are always valid, since gcc.c itself understands the
3510          first two, gfortranspec.c understands -static-libgfortran and
3511          g++spec.c understands -static-libstdc++ */
3512       validated = true;
3513       break;
3514
3515     default:
3516       /* Various driver options need no special processing at this
3517          point, having been handled in a prescan above or being
3518          handled by specs.  */
3519       break;
3520     }
3521
3522   if (do_save)
3523     save_switch (decoded->canonical_option[0],
3524                  decoded->canonical_option_num_elements - 1,
3525                  &decoded->canonical_option[1], validated);
3526   return true;
3527 }
3528
3529 /* Put the driver's standard set of option handlers in *HANDLERS.  */
3530
3531 static void
3532 set_option_handlers (struct cl_option_handlers *handlers)
3533 {
3534   handlers->unknown_option_callback = driver_unknown_option_callback;
3535   handlers->wrong_lang_callback = driver_wrong_lang_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           case '(':
5217             {
5218               const char *name = p;
5219               struct spec_list *sl;
5220               int len;
5221
5222               /* The string after the S/P is the name of a spec that is to be
5223                  processed.  */
5224               while (*p && *p != ')')
5225                 p++;
5226
5227               /* See if it's in the list.  */
5228               for (len = p - name, sl = specs; sl; sl = sl->next)
5229                 if (sl->name_len == len && !strncmp (sl->name, name, len))
5230                   {
5231                     name = *(sl->ptr_spec);
5232 #ifdef DEBUG_SPECS
5233                     fnotice (stderr, "Processing spec (%s), which is '%s'\n",
5234                              sl->name, name);
5235 #endif
5236                     break;
5237                   }
5238
5239               if (sl)
5240                 {
5241                   value = do_spec_1 (name, 0, NULL);
5242                   if (value != 0)
5243                     return value;
5244                 }
5245
5246               /* Discard the closing paren.  */
5247               if (*p)
5248                 p++;
5249             }
5250             break;
5251
5252           default:
5253             error ("spec failure: unrecognized spec option %qc", c);
5254             break;
5255           }
5256         break;
5257
5258       case '\\':
5259         /* Backslash: treat next character as ordinary.  */
5260         c = *p++;
5261
5262         /* Fall through.  */
5263       default:
5264         /* Ordinary character: put it into the current argument.  */
5265         obstack_1grow (&obstack, c);
5266         arg_going = 1;
5267       }
5268
5269   /* End of string.  If we are processing a spec function, we need to
5270      end any pending argument.  */
5271   if (processing_spec_function)
5272     end_going_arg ();
5273
5274   return 0;
5275 }
5276
5277 /* Look up a spec function.  */
5278
5279 static const struct spec_function *
5280 lookup_spec_function (const char *name)
5281 {
5282   const struct spec_function *sf;
5283
5284   for (sf = static_spec_functions; sf->name != NULL; sf++)
5285     if (strcmp (sf->name, name) == 0)
5286       return sf;
5287
5288   return NULL;
5289 }
5290
5291 /* Evaluate a spec function.  */
5292
5293 static const char *
5294 eval_spec_function (const char *func, const char *args)
5295 {
5296   const struct spec_function *sf;
5297   const char *funcval;
5298
5299   /* Saved spec processing context.  */
5300   VEC(const_char_p,heap) *save_argbuf;
5301
5302   int save_arg_going;
5303   int save_delete_this_arg;
5304   int save_this_is_output_file;
5305   int save_this_is_library_file;
5306   int save_input_from_pipe;
5307   int save_this_is_linker_script;
5308   const char *save_suffix_subst;
5309
5310
5311   sf = lookup_spec_function (func);
5312   if (sf == NULL)
5313     fatal_error ("unknown spec function %qs", func);
5314
5315   /* Push the spec processing context.  */
5316   save_argbuf = argbuf;
5317
5318   save_arg_going = arg_going;
5319   save_delete_this_arg = delete_this_arg;
5320   save_this_is_output_file = this_is_output_file;
5321   save_this_is_library_file = this_is_library_file;
5322   save_this_is_linker_script = this_is_linker_script;
5323   save_input_from_pipe = input_from_pipe;
5324   save_suffix_subst = suffix_subst;
5325
5326   /* Create a new spec processing context, and build the function
5327      arguments.  */
5328
5329   alloc_args ();
5330   if (do_spec_2 (args) < 0)
5331     fatal_error ("error in args to spec function %qs", func);
5332
5333   /* argbuf_index is an index for the next argument to be inserted, and
5334      so contains the count of the args already inserted.  */
5335
5336   funcval = (*sf->func) (VEC_length (const_char_p, argbuf),
5337                          VEC_address (const_char_p, argbuf));
5338
5339   /* Pop the spec processing context.  */
5340   VEC_free (const_char_p, heap, argbuf);
5341   argbuf = save_argbuf;
5342
5343   arg_going = save_arg_going;
5344   delete_this_arg = save_delete_this_arg;
5345   this_is_output_file = save_this_is_output_file;
5346   this_is_library_file = save_this_is_library_file;
5347   this_is_linker_script = save_this_is_linker_script;
5348   input_from_pipe = save_input_from_pipe;
5349   suffix_subst = save_suffix_subst;
5350
5351   return funcval;
5352 }
5353
5354 /* Handle a spec function call of the form:
5355
5356    %:function(args)
5357
5358    ARGS is processed as a spec in a separate context and split into an
5359    argument vector in the normal fashion.  The function returns a string
5360    containing a spec which we then process in the caller's context, or
5361    NULL if no processing is required.  */
5362
5363 static const char *
5364 handle_spec_function (const char *p)
5365 {
5366   char *func, *args;
5367   const char *endp, *funcval;
5368   int count;
5369
5370   processing_spec_function++;
5371
5372   /* Get the function name.  */
5373   for (endp = p; *endp != '\0'; endp++)
5374     {
5375       if (*endp == '(')         /* ) */
5376         break;
5377       /* Only allow [A-Za-z0-9], -, and _ in function names.  */
5378       if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
5379         fatal_error ("malformed spec function name");
5380     }
5381   if (*endp != '(')             /* ) */
5382     fatal_error ("no arguments for spec function");
5383   func = save_string (p, endp - p);
5384   p = ++endp;
5385
5386   /* Get the arguments.  */
5387   for (count = 0; *endp != '\0'; endp++)
5388     {
5389       /* ( */
5390       if (*endp == ')')
5391         {
5392           if (count == 0)
5393             break;
5394           count--;
5395         }
5396       else if (*endp == '(')    /* ) */
5397         count++;
5398     }
5399   /* ( */
5400   if (*endp != ')')
5401     fatal_error ("malformed spec function arguments");
5402   args = save_string (p, endp - p);
5403   p = ++endp;
5404
5405   /* p now points to just past the end of the spec function expression.  */
5406
5407   funcval = eval_spec_function (func, args);
5408   if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
5409     p = NULL;
5410
5411   free (func);
5412   free (args);
5413
5414   processing_spec_function--;
5415
5416   return p;
5417 }
5418
5419 /* Inline subroutine of handle_braces.  Returns true if the current
5420    input suffix matches the atom bracketed by ATOM and END_ATOM.  */
5421 static inline bool
5422 input_suffix_matches (const char *atom, const char *end_atom)
5423 {
5424   return (input_suffix
5425           && !strncmp (input_suffix, atom, end_atom - atom)
5426           && input_suffix[end_atom - atom] == '\0');
5427 }
5428
5429 /* Subroutine of handle_braces.  Returns true if the current
5430    input file's spec name matches the atom bracketed by ATOM and END_ATOM.  */
5431 static bool
5432 input_spec_matches (const char *atom, const char *end_atom)
5433 {
5434   return (input_file_compiler
5435           && input_file_compiler->suffix
5436           && input_file_compiler->suffix[0] != '\0'
5437           && !strncmp (input_file_compiler->suffix + 1, atom,
5438                        end_atom - atom)
5439           && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
5440 }
5441
5442 /* Subroutine of handle_braces.  Returns true if a switch
5443    matching the atom bracketed by ATOM and END_ATOM appeared on the
5444    command line.  */
5445 static bool
5446 switch_matches (const char *atom, const char *end_atom, int starred)
5447 {
5448   int i;
5449   int len = end_atom - atom;
5450   int plen = starred ? len : -1;
5451
5452   for (i = 0; i < n_switches; i++)
5453     if (!strncmp (switches[i].part1, atom, len)
5454         && (starred || switches[i].part1[len] == '\0')
5455         && check_live_switch (i, plen))
5456       return true;
5457
5458     /* Check if a switch with separated form matching the atom.
5459        We check -D and -U switches. */
5460     else if (switches[i].args != 0)
5461       {
5462         if ((*switches[i].part1 == 'D' || *switches[i].part1 == 'U')
5463             && *switches[i].part1 == atom[0])
5464           {
5465             if (!strncmp (switches[i].args[0], &atom[1], len - 1)
5466                 && (starred || (switches[i].part1[1] == '\0'
5467                                 && switches[i].args[0][len - 1] == '\0'))
5468                 && check_live_switch (i, (starred ? 1 : -1)))
5469               return true;
5470           }
5471       }
5472
5473   return false;
5474 }
5475
5476 /* Inline subroutine of handle_braces.  Mark all of the switches which
5477    match ATOM (extends to END_ATOM; STARRED indicates whether there
5478    was a star after the atom) for later processing.  */
5479 static inline void
5480 mark_matching_switches (const char *atom, const char *end_atom, int starred)
5481 {
5482   int i;
5483   int len = end_atom - atom;
5484   int plen = starred ? len : -1;
5485
5486   for (i = 0; i < n_switches; i++)
5487     if (!strncmp (switches[i].part1, atom, len)
5488         && (starred || switches[i].part1[len] == '\0')
5489         && check_live_switch (i, plen))
5490       switches[i].ordering = 1;
5491 }
5492
5493 /* Inline subroutine of handle_braces.  Process all the currently
5494    marked switches through give_switch, and clear the marks.  */
5495 static inline void
5496 process_marked_switches (void)
5497 {
5498   int i;
5499
5500   for (i = 0; i < n_switches; i++)
5501     if (switches[i].ordering == 1)
5502       {
5503         switches[i].ordering = 0;
5504         give_switch (i, 0);
5505       }
5506 }
5507
5508 /* Handle a %{ ... } construct.  P points just inside the leading {.
5509    Returns a pointer one past the end of the brace block, or 0
5510    if we call do_spec_1 and that returns -1.  */
5511
5512 static const char *
5513 handle_braces (const char *p)
5514 {
5515   const char *atom, *end_atom;
5516   const char *d_atom = NULL, *d_end_atom = NULL;
5517   const char *orig = p;
5518
5519   bool a_is_suffix;
5520   bool a_is_spectype;
5521   bool a_is_starred;
5522   bool a_is_negated;
5523   bool a_matched;
5524
5525   bool a_must_be_last = false;
5526   bool ordered_set    = false;
5527   bool disjunct_set   = false;
5528   bool disj_matched   = false;
5529   bool disj_starred   = true;
5530   bool n_way_choice   = false;
5531   bool n_way_matched  = false;
5532
5533 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5534
5535   do
5536     {
5537       if (a_must_be_last)
5538         goto invalid;
5539
5540       /* Scan one "atom" (S in the description above of %{}, possibly
5541          with '!', '.', '@', ',', or '*' modifiers).  */
5542       a_matched = false;
5543       a_is_suffix = false;
5544       a_is_starred = false;
5545       a_is_negated = false;
5546       a_is_spectype = false;
5547
5548       SKIP_WHITE();
5549       if (*p == '!')
5550         p++, a_is_negated = true;
5551
5552       SKIP_WHITE();
5553       if (*p == '.')
5554         p++, a_is_suffix = true;
5555       else if (*p == ',')
5556         p++, a_is_spectype = true;
5557
5558       atom = p;
5559       while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
5560              || *p == ',' || *p == '.' || *p == '@')
5561         p++;
5562       end_atom = p;
5563
5564       if (*p == '*')
5565         p++, a_is_starred = 1;
5566
5567       SKIP_WHITE();
5568       switch (*p)
5569         {
5570         case '&': case '}':
5571           /* Substitute the switch(es) indicated by the current atom.  */
5572           ordered_set = true;
5573           if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
5574               || a_is_spectype || atom == end_atom)
5575             goto invalid;
5576
5577           mark_matching_switches (atom, end_atom, a_is_starred);
5578
5579           if (*p == '}')
5580             process_marked_switches ();
5581           break;
5582
5583         case '|': case ':':
5584           /* Substitute some text if the current atom appears as a switch
5585              or suffix.  */
5586           disjunct_set = true;
5587           if (ordered_set)
5588             goto invalid;
5589
5590           if (atom == end_atom)
5591             {
5592               if (!n_way_choice || disj_matched || *p == '|'
5593                   || a_is_negated || a_is_suffix || a_is_spectype
5594                   || a_is_starred)
5595                 goto invalid;
5596
5597               /* An empty term may appear as the last choice of an
5598                  N-way choice set; it means "otherwise".  */
5599               a_must_be_last = true;
5600               disj_matched = !n_way_matched;
5601               disj_starred = false;
5602             }
5603           else
5604             {
5605               if ((a_is_suffix || a_is_spectype) && a_is_starred)
5606                 goto invalid;
5607
5608               if (!a_is_starred)
5609                 disj_starred = false;
5610
5611               /* Don't bother testing this atom if we already have a
5612                  match.  */
5613               if (!disj_matched && !n_way_matched)
5614                 {
5615                   if (a_is_suffix)
5616                     a_matched = input_suffix_matches (atom, end_atom);
5617                   else if (a_is_spectype)
5618                     a_matched = input_spec_matches (atom, end_atom);
5619                   else
5620                     a_matched = switch_matches (atom, end_atom, a_is_starred);
5621
5622                   if (a_matched != a_is_negated)
5623                     {
5624                       disj_matched = true;
5625                       d_atom = atom;
5626                       d_end_atom = end_atom;
5627                     }
5628                 }
5629             }
5630
5631           if (*p == ':')
5632             {
5633               /* Found the body, that is, the text to substitute if the
5634                  current disjunction matches.  */
5635               p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
5636                                       disj_matched && !n_way_matched);
5637               if (p == 0)
5638                 return 0;
5639
5640               /* If we have an N-way choice, reset state for the next
5641                  disjunction.  */
5642               if (*p == ';')
5643                 {
5644                   n_way_choice = true;
5645                   n_way_matched |= disj_matched;
5646                   disj_matched = false;
5647                   disj_starred = true;
5648                   d_atom = d_end_atom = NULL;
5649                 }
5650             }
5651           break;
5652
5653         default:
5654           goto invalid;
5655         }
5656     }
5657   while (*p++ != '}');
5658
5659   return p;
5660
5661  invalid:
5662   fatal_error ("braced spec %qs is invalid at %qc", orig, *p);
5663
5664 #undef SKIP_WHITE
5665 }
5666
5667 /* Subroutine of handle_braces.  Scan and process a brace substitution body
5668    (X in the description of %{} syntax).  P points one past the colon;
5669    ATOM and END_ATOM bracket the first atom which was found to be true
5670    (present) in the current disjunction; STARRED indicates whether all
5671    the atoms in the current disjunction were starred (for syntax validation);
5672    MATCHED indicates whether the disjunction matched or not, and therefore
5673    whether or not the body is to be processed through do_spec_1 or just
5674    skipped.  Returns a pointer to the closing } or ;, or 0 if do_spec_1
5675    returns -1.  */
5676
5677 static const char *
5678 process_brace_body (const char *p, const char *atom, const char *end_atom,
5679                     int starred, int matched)
5680 {
5681   const char *body, *end_body;
5682   unsigned int nesting_level;
5683   bool have_subst     = false;
5684
5685   /* Locate the closing } or ;, honoring nested braces.
5686      Trim trailing whitespace.  */
5687   body = p;
5688   nesting_level = 1;
5689   for (;;)
5690     {
5691       if (*p == '{')
5692         nesting_level++;
5693       else if (*p == '}')
5694         {
5695           if (!--nesting_level)
5696             break;
5697         }
5698       else if (*p == ';' && nesting_level == 1)
5699         break;
5700       else if (*p == '%' && p[1] == '*' && nesting_level == 1)
5701         have_subst = true;
5702       else if (*p == '\0')
5703         goto invalid;
5704       p++;
5705     }
5706
5707   end_body = p;
5708   while (end_body[-1] == ' ' || end_body[-1] == '\t')
5709     end_body--;
5710
5711   if (have_subst && !starred)
5712     goto invalid;
5713
5714   if (matched)
5715     {
5716       /* Copy the substitution body to permanent storage and execute it.
5717          If have_subst is false, this is a simple matter of running the
5718          body through do_spec_1...  */
5719       char *string = save_string (body, end_body - body);
5720       if (!have_subst)
5721         {
5722           if (do_spec_1 (string, 0, NULL) < 0)
5723             return 0;
5724         }
5725       else
5726         {
5727           /* ... but if have_subst is true, we have to process the
5728              body once for each matching switch, with %* set to the
5729              variant part of the switch.  */
5730           unsigned int hard_match_len = end_atom - atom;
5731           int i;
5732
5733           for (i = 0; i < n_switches; i++)
5734             if (!strncmp (switches[i].part1, atom, hard_match_len)
5735                 && check_live_switch (i, hard_match_len))
5736               {
5737                 if (do_spec_1 (string, 0,
5738                                &switches[i].part1[hard_match_len]) < 0)
5739                   return 0;
5740                 /* Pass any arguments this switch has.  */
5741                 give_switch (i, 1);
5742                 suffix_subst = NULL;
5743               }
5744         }
5745     }
5746
5747   return p;
5748
5749  invalid:
5750   fatal_error ("braced spec body %qs is invalid", body);
5751 }
5752 \f
5753 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5754    on the command line.  PREFIX_LENGTH is the length of XXX in an {XXX*}
5755    spec, or -1 if either exact match or %* is used.
5756
5757    A -O switch is obsoleted by a later -O switch.  A -f, -m, or -W switch
5758    whose value does not begin with "no-" is obsoleted by the same value
5759    with the "no-", similarly for a switch with the "no-" prefix.  */
5760
5761 static int
5762 check_live_switch (int switchnum, int prefix_length)
5763 {
5764   const char *name = switches[switchnum].part1;
5765   int i;
5766
5767   /* If we already processed this switch and determined if it was
5768      live or not, return our past determination.  */
5769   if (switches[switchnum].live_cond != 0)
5770     return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
5771             && (switches[switchnum].live_cond & SWITCH_FALSE) == 0
5772             && (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
5773                == 0);
5774
5775   /* In the common case of {<at-most-one-letter>*}, a negating
5776      switch would always match, so ignore that case.  We will just
5777      send the conflicting switches to the compiler phase.  */
5778   if (prefix_length >= 0 && prefix_length <= 1)
5779     return 1;
5780
5781   /* Now search for duplicate in a manner that depends on the name.  */
5782   switch (*name)
5783     {
5784     case 'O':
5785       for (i = switchnum + 1; i < n_switches; i++)
5786         if (switches[i].part1[0] == 'O')
5787           {
5788             switches[switchnum].validated = 1;
5789             switches[switchnum].live_cond = SWITCH_FALSE;
5790             return 0;
5791           }
5792       break;
5793
5794     case 'W':  case 'f':  case 'm':
5795       if (! strncmp (name + 1, "no-", 3))
5796         {
5797           /* We have Xno-YYY, search for XYYY.  */
5798           for (i = switchnum + 1; i < n_switches; i++)
5799             if (switches[i].part1[0] == name[0]
5800                 && ! strcmp (&switches[i].part1[1], &name[4]))
5801               {
5802                 switches[switchnum].validated = 1;
5803                 switches[switchnum].live_cond = SWITCH_FALSE;
5804                 return 0;
5805               }
5806         }
5807       else
5808         {
5809           /* We have XYYY, search for Xno-YYY.  */
5810           for (i = switchnum + 1; i < n_switches; i++)
5811             if (switches[i].part1[0] == name[0]
5812                 && switches[i].part1[1] == 'n'
5813                 && switches[i].part1[2] == 'o'
5814                 && switches[i].part1[3] == '-'
5815                 && !strcmp (&switches[i].part1[4], &name[1]))
5816               {
5817                 switches[switchnum].validated = 1;
5818                 switches[switchnum].live_cond = SWITCH_FALSE;
5819                 return 0;
5820               }
5821         }
5822       break;
5823     }
5824
5825   /* Otherwise the switch is live.  */
5826   switches[switchnum].live_cond |= SWITCH_LIVE;
5827   return 1;
5828 }
5829 \f
5830 /* Pass a switch to the current accumulating command
5831    in the same form that we received it.
5832    SWITCHNUM identifies the switch; it is an index into
5833    the vector of switches gcc received, which is `switches'.
5834    This cannot fail since it never finishes a command line.
5835
5836    If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.  */
5837
5838 static void
5839 give_switch (int switchnum, int omit_first_word)
5840 {
5841   if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
5842     return;
5843
5844   if (!omit_first_word)
5845     {
5846       do_spec_1 ("-", 0, NULL);
5847       do_spec_1 (switches[switchnum].part1, 1, NULL);
5848     }
5849
5850   if (switches[switchnum].args != 0)
5851     {
5852       const char **p;
5853       for (p = switches[switchnum].args; *p; p++)
5854         {
5855           const char *arg = *p;
5856
5857           do_spec_1 (" ", 0, NULL);
5858           if (suffix_subst)
5859             {
5860               unsigned length = strlen (arg);
5861               int dot = 0;
5862
5863               while (length-- && !IS_DIR_SEPARATOR (arg[length]))
5864                 if (arg[length] == '.')
5865                   {
5866                     (CONST_CAST(char *, arg))[length] = 0;
5867                     dot = 1;
5868                     break;
5869                   }
5870               do_spec_1 (arg, 1, NULL);
5871               if (dot)
5872                 (CONST_CAST(char *, arg))[length] = '.';
5873               do_spec_1 (suffix_subst, 1, NULL);
5874             }
5875           else
5876             do_spec_1 (arg, 1, NULL);
5877         }
5878     }
5879
5880   do_spec_1 (" ", 0, NULL);
5881   switches[switchnum].validated = 1;
5882 }
5883 \f
5884 /* Search for a file named NAME trying various prefixes including the
5885    user's -B prefix and some standard ones.
5886    Return the absolute file name found.  If nothing is found, return NAME.  */
5887
5888 static const char *
5889 find_file (const char *name)
5890 {
5891   char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
5892   return newname ? newname : name;
5893 }
5894
5895 /* Determine whether a directory exists.  If LINKER, return 0 for
5896    certain fixed names not needed by the linker.  */
5897
5898 static int
5899 is_directory (const char *path1, bool linker)
5900 {
5901   int len1;
5902   char *path;
5903   char *cp;
5904   struct stat st;
5905
5906   /* Ensure the string ends with "/.".  The resulting path will be a
5907      directory even if the given path is a symbolic link.  */
5908   len1 = strlen (path1);
5909   path = (char *) alloca (3 + len1);
5910   memcpy (path, path1, len1);
5911   cp = path + len1;
5912   if (!IS_DIR_SEPARATOR (cp[-1]))
5913     *cp++ = DIR_SEPARATOR;
5914   *cp++ = '.';
5915   *cp = '\0';
5916
5917   /* Exclude directories that the linker is known to search.  */
5918   if (linker
5919       && IS_DIR_SEPARATOR (path[0])
5920       && ((cp - path == 6
5921            && filename_ncmp (path + 1, "lib", 3) == 0)
5922           || (cp - path == 10
5923               && filename_ncmp (path + 1, "usr", 3) == 0
5924               && IS_DIR_SEPARATOR (path[4])
5925               && filename_ncmp (path + 5, "lib", 3) == 0)))
5926     return 0;
5927
5928   return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
5929 }
5930
5931 /* Set up the various global variables to indicate that we're processing
5932    the input file named FILENAME.  */
5933
5934 void
5935 set_input (const char *filename)
5936 {
5937   const char *p;
5938
5939   gcc_input_filename = filename;
5940   input_filename_length = strlen (gcc_input_filename);
5941   input_basename = lbasename (gcc_input_filename);
5942
5943   /* Find a suffix starting with the last period,
5944      and set basename_length to exclude that suffix.  */
5945   basename_length = strlen (input_basename);
5946   suffixed_basename_length = basename_length;
5947   p = input_basename + basename_length;
5948   while (p != input_basename && *p != '.')
5949     --p;
5950   if (*p == '.' && p != input_basename)
5951     {
5952       basename_length = p - input_basename;
5953       input_suffix = p + 1;
5954     }
5955   else
5956     input_suffix = "";
5957
5958   /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
5959      we will need to do a stat on the gcc_input_filename.  The
5960      INPUT_STAT_SET signals that the stat is needed.  */
5961   input_stat_set = 0;
5962 }
5963 \f
5964 /* On fatal signals, delete all the temporary files.  */
5965
5966 static void
5967 fatal_signal (int signum)
5968 {
5969   signal (signum, SIG_DFL);
5970   delete_failure_queue ();
5971   delete_temp_files ();
5972   /* Get the same signal again, this time not handled,
5973      so its normal effect occurs.  */
5974   kill (getpid (), signum);
5975 }
5976
5977 /* Compare the contents of the two files named CMPFILE[0] and
5978    CMPFILE[1].  Return zero if they're identical, nonzero
5979    otherwise.  */
5980
5981 static int
5982 compare_files (char *cmpfile[])
5983 {
5984   int ret = 0;
5985   FILE *temp[2] = { NULL, NULL };
5986   int i;
5987
5988 #if HAVE_MMAP_FILE
5989   {
5990     size_t length[2];
5991     void *map[2] = { NULL, NULL };
5992
5993     for (i = 0; i < 2; i++)
5994       {
5995         struct stat st;
5996
5997         if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode))
5998           {
5999             error ("%s: could not determine length of compare-debug file %s",
6000                    gcc_input_filename, cmpfile[i]);
6001             ret = 1;
6002             break;
6003           }
6004
6005         length[i] = st.st_size;
6006       }
6007
6008     if (!ret && length[0] != length[1])
6009       {
6010         error ("%s: -fcompare-debug failure (length)", gcc_input_filename);
6011         ret = 1;
6012       }
6013
6014     if (!ret)
6015       for (i = 0; i < 2; i++)
6016         {
6017           int fd = open (cmpfile[i], O_RDONLY);
6018           if (fd < 0)
6019             {
6020               error ("%s: could not open compare-debug file %s",
6021                      gcc_input_filename, cmpfile[i]);
6022               ret = 1;
6023               break;
6024             }
6025
6026           map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0);
6027           close (fd);
6028
6029           if (map[i] == (void *) MAP_FAILED)
6030             {
6031               ret = -1;
6032               break;
6033             }
6034         }
6035
6036     if (!ret)
6037       {
6038         if (memcmp (map[0], map[1], length[0]) != 0)
6039           {
6040             error ("%s: -fcompare-debug failure", gcc_input_filename);
6041             ret = 1;
6042           }
6043       }
6044
6045     for (i = 0; i < 2; i++)
6046       if (map[i])
6047         munmap ((caddr_t) map[i], length[i]);
6048
6049     if (ret >= 0)
6050       return ret;
6051
6052     ret = 0;
6053   }
6054 #endif
6055
6056   for (i = 0; i < 2; i++)
6057     {
6058       temp[i] = fopen (cmpfile[i], "r");
6059       if (!temp[i])
6060         {
6061           error ("%s: could not open compare-debug file %s",
6062                  gcc_input_filename, cmpfile[i]);
6063           ret = 1;
6064           break;
6065         }
6066     }
6067
6068   if (!ret && temp[0] && temp[1])
6069     for (;;)
6070       {
6071         int c0, c1;
6072         c0 = fgetc (temp[0]);
6073         c1 = fgetc (temp[1]);
6074
6075         if (c0 != c1)
6076           {
6077             error ("%s: -fcompare-debug failure",
6078                    gcc_input_filename);
6079             ret = 1;
6080             break;
6081           }
6082
6083         if (c0 == EOF)
6084           break;
6085       }
6086
6087   for (i = 1; i >= 0; i--)
6088     {
6089       if (temp[i])
6090         fclose (temp[i]);
6091     }
6092
6093   return ret;
6094 }
6095
6096 extern int main (int, char **);
6097
6098 int
6099 main (int argc, char **argv)
6100 {
6101   size_t i;
6102   int value;
6103   int linker_was_run = 0;
6104   int lang_n_infiles = 0;
6105   int num_linker_inputs = 0;
6106   char *explicit_link_files;
6107   char *specs_file;
6108   char *lto_wrapper_file;
6109   const char *p;
6110   struct user_specs *uptr;
6111   char **old_argv = argv;
6112   struct cl_decoded_option *decoded_options;
6113   unsigned int decoded_options_count;
6114
6115   /* Initialize here, not in definition.  The IRIX 6 O32 cc sometimes chokes
6116      on ?: in file-scope variable initializations.  */
6117   asm_debug = ASM_DEBUG_SPEC;
6118
6119   p = argv[0] + strlen (argv[0]);
6120   while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6121     --p;
6122   progname = p;
6123
6124   xmalloc_set_program_name (progname);
6125
6126   expandargv (&argc, &argv);
6127
6128   /* Determine if any expansions were made.  */
6129   if (argv != old_argv)
6130     at_file_supplied = true;
6131
6132   /* Register the language-independent parameters.  */
6133   global_init_params ();
6134   finish_params ();
6135
6136   init_options_struct (&global_options, &global_options_set);
6137
6138   decode_cmdline_options_to_array (argc, CONST_CAST2 (const char **, char **,
6139                                                       argv),
6140                                    CL_DRIVER,
6141                                    &decoded_options, &decoded_options_count);
6142
6143 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6144   /* Perform host dependent initialization when needed.  */
6145   GCC_DRIVER_HOST_INITIALIZATION;
6146 #endif
6147
6148   /* Unlock the stdio streams.  */
6149   unlock_std_streams ();
6150
6151   gcc_init_libintl ();
6152
6153   diagnostic_initialize (global_dc, 0);
6154   if (atexit (delete_temp_files) != 0)
6155     fatal_error ("atexit failed");
6156
6157   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6158     signal (SIGINT, fatal_signal);
6159 #ifdef SIGHUP
6160   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6161     signal (SIGHUP, fatal_signal);
6162 #endif
6163   if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6164     signal (SIGTERM, fatal_signal);
6165 #ifdef SIGPIPE
6166   if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6167     signal (SIGPIPE, fatal_signal);
6168 #endif
6169 #ifdef SIGCHLD
6170   /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6171      receive the signal.  A different setting is inheritable */
6172   signal (SIGCHLD, SIG_DFL);
6173 #endif
6174
6175   /* Parsing and gimplification sometimes need quite large stack.
6176      Increase stack size limits if possible.  */
6177   stack_limit_increase (64 * 1024 * 1024);
6178
6179   /* Allocate the argument vector.  */
6180   alloc_args ();
6181
6182   obstack_init (&obstack);
6183
6184   /* Build multilib_select, et. al from the separate lines that make up each
6185      multilib selection.  */
6186   {
6187     const char *const *q = multilib_raw;
6188     int need_space;
6189
6190     obstack_init (&multilib_obstack);
6191     while ((p = *q++) != (char *) 0)
6192       obstack_grow (&multilib_obstack, p, strlen (p));
6193
6194     obstack_1grow (&multilib_obstack, 0);
6195     multilib_select = XOBFINISH (&multilib_obstack, const char *);
6196
6197     q = multilib_matches_raw;
6198     while ((p = *q++) != (char *) 0)
6199       obstack_grow (&multilib_obstack, p, strlen (p));
6200
6201     obstack_1grow (&multilib_obstack, 0);
6202     multilib_matches = XOBFINISH (&multilib_obstack, const char *);
6203
6204     q = multilib_exclusions_raw;
6205     while ((p = *q++) != (char *) 0)
6206       obstack_grow (&multilib_obstack, p, strlen (p));
6207
6208     obstack_1grow (&multilib_obstack, 0);
6209     multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
6210
6211     need_space = FALSE;
6212     for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6213       {
6214         if (need_space)
6215           obstack_1grow (&multilib_obstack, ' ');
6216         obstack_grow (&multilib_obstack,
6217                       multilib_defaults_raw[i],
6218                       strlen (multilib_defaults_raw[i]));
6219         need_space = TRUE;
6220       }
6221
6222     obstack_1grow (&multilib_obstack, 0);
6223     multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
6224   }
6225
6226 #ifdef INIT_ENVIRONMENT
6227   /* Set up any other necessary machine specific environment variables.  */
6228   xputenv (INIT_ENVIRONMENT);
6229 #endif
6230
6231   /* Make a table of what switches there are (switches, n_switches).
6232      Make a table of specified input files (infiles, n_infiles).
6233      Decode switches that are handled locally.  */
6234
6235   process_command (decoded_options_count, decoded_options);
6236
6237   /* Initialize the vector of specs to just the default.
6238      This means one element containing 0s, as a terminator.  */
6239
6240   compilers = XNEWVAR (struct compiler, sizeof default_compilers);
6241   memcpy (compilers, default_compilers, sizeof default_compilers);
6242   n_compilers = n_default_compilers;
6243
6244   /* Read specs from a file if there is one.  */
6245
6246   machine_suffix = concat (spec_machine, dir_separator_str,
6247                            spec_version, dir_separator_str, NULL);
6248   just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6249
6250   specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
6251   /* Read the specs file unless it is a default one.  */
6252   if (specs_file != 0 && strcmp (specs_file, "specs"))
6253     read_specs (specs_file, TRUE);
6254   else
6255     init_spec ();
6256
6257   /* We need to check standard_exec_prefix/just_machine_suffix/specs
6258      for any override of as, ld and libraries.  */
6259   specs_file = (char *) alloca (strlen (standard_exec_prefix)
6260                        + strlen (just_machine_suffix) + sizeof ("specs"));
6261
6262   strcpy (specs_file, standard_exec_prefix);
6263   strcat (specs_file, just_machine_suffix);
6264   strcat (specs_file, "specs");
6265   if (access (specs_file, R_OK) == 0)
6266     read_specs (specs_file, TRUE);
6267
6268   /* Process any configure-time defaults specified for the command line
6269      options, via OPTION_DEFAULT_SPECS.  */
6270   for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6271     do_option_spec (option_default_specs[i].name,
6272                     option_default_specs[i].spec);
6273
6274   /* Process DRIVER_SELF_SPECS, adding any new options to the end
6275      of the command line.  */
6276
6277   for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6278     do_self_spec (driver_self_specs[i]);
6279
6280   /* If not cross-compiling, look for executables in the standard
6281      places.  */
6282   if (*cross_compile == '0')
6283     {
6284       if (*md_exec_prefix)
6285         {
6286           add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6287                       PREFIX_PRIORITY_LAST, 0, 0);
6288         }
6289     }
6290
6291   /* Process sysroot_suffix_spec.  */
6292   if (*sysroot_suffix_spec != 0
6293       && do_spec_2 (sysroot_suffix_spec) == 0)
6294     {
6295       if (VEC_length (const_char_p, argbuf) > 1)
6296         error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6297       else if (VEC_length (const_char_p, argbuf) == 1)
6298         target_sysroot_suffix = xstrdup (VEC_last (const_char_p, argbuf));
6299     }
6300
6301 #ifdef HAVE_LD_SYSROOT
6302   /* Pass the --sysroot option to the linker, if it supports that.  If
6303      there is a sysroot_suffix_spec, it has already been processed by
6304      this point, so target_system_root really is the system root we
6305      should be using.  */
6306   if (target_system_root)
6307     {
6308       obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6309       obstack_grow0 (&obstack, link_spec, strlen (link_spec));
6310       set_spec ("link", XOBFINISH (&obstack, const char *));
6311     }
6312 #endif
6313
6314   /* Process sysroot_hdrs_suffix_spec.  */
6315   if (*sysroot_hdrs_suffix_spec != 0
6316       && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6317     {
6318       if (VEC_length (const_char_p, argbuf) > 1)
6319         error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6320       else if (VEC_length (const_char_p, argbuf) == 1)
6321         target_sysroot_hdrs_suffix = xstrdup (VEC_last (const_char_p, argbuf));
6322     }
6323
6324   /* Look for startfiles in the standard places.  */
6325   if (*startfile_prefix_spec != 0
6326       && do_spec_2 (startfile_prefix_spec) == 0
6327       && do_spec_1 (" ", 0, NULL) == 0)
6328     {
6329       const char *arg;
6330       int ndx;
6331       FOR_EACH_VEC_ELT (const_char_p, argbuf, ndx, arg)
6332         add_sysrooted_prefix (&startfile_prefixes, arg, "BINUTILS",
6333                               PREFIX_PRIORITY_LAST, 0, 1);
6334     }
6335   /* We should eventually get rid of all these and stick to
6336      startfile_prefix_spec exclusively.  */
6337   else if (*cross_compile == '0' || target_system_root)
6338     {
6339       if (*md_startfile_prefix)
6340         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
6341                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6342
6343       if (*md_startfile_prefix_1)
6344         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
6345                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6346
6347       /* If standard_startfile_prefix is relative, base it on
6348          standard_exec_prefix.  This lets us move the installed tree
6349          as a unit.  If GCC_EXEC_PREFIX is defined, base
6350          standard_startfile_prefix on that as well.
6351
6352          If the prefix is relative, only search it for native compilers;
6353          otherwise we will search a directory containing host libraries.  */
6354       if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
6355         add_sysrooted_prefix (&startfile_prefixes,
6356                               standard_startfile_prefix, "BINUTILS",
6357                               PREFIX_PRIORITY_LAST, 0, 1);
6358       else if (*cross_compile == '0')
6359         {
6360           add_prefix (&startfile_prefixes,
6361                       concat (gcc_exec_prefix
6362                               ? gcc_exec_prefix : standard_exec_prefix,
6363                               machine_suffix,
6364                               standard_startfile_prefix, NULL),
6365                       NULL, PREFIX_PRIORITY_LAST, 0, 1);
6366         }
6367
6368       /* Sysrooted prefixes are relocated because target_system_root is
6369          also relocated by gcc_exec_prefix.  */
6370       if (*standard_startfile_prefix_1)
6371         add_sysrooted_prefix (&startfile_prefixes,
6372                               standard_startfile_prefix_1, "BINUTILS",
6373                               PREFIX_PRIORITY_LAST, 0, 1);
6374       if (*standard_startfile_prefix_2)
6375         add_sysrooted_prefix (&startfile_prefixes,
6376                               standard_startfile_prefix_2, "BINUTILS",
6377                               PREFIX_PRIORITY_LAST, 0, 1);
6378     }
6379
6380   /* Process any user specified specs in the order given on the command
6381      line.  */
6382   for (uptr = user_specs_head; uptr; uptr = uptr->next)
6383     {
6384       char *filename = find_a_file (&startfile_prefixes, uptr->filename,
6385                                     R_OK, true);
6386       read_specs (filename ? filename : uptr->filename, FALSE);
6387     }
6388
6389   /* Process any user self specs.  */
6390   {
6391     struct spec_list *sl;
6392     for (sl = specs; sl; sl = sl->next)
6393       if (sl->name_len == sizeof "self_spec" - 1
6394           && !strcmp (sl->name, "self_spec"))
6395         do_self_spec (*sl->ptr_spec);
6396   }
6397
6398   if (compare_debug)
6399     {
6400       enum save_temps save;
6401
6402       if (!compare_debug_second)
6403         {
6404           n_switches_debug_check[1] = n_switches;
6405           n_switches_alloc_debug_check[1] = n_switches_alloc;
6406           switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
6407                                              n_switches_alloc);
6408
6409           do_self_spec ("%:compare-debug-self-opt()");
6410           n_switches_debug_check[0] = n_switches;
6411           n_switches_alloc_debug_check[0] = n_switches_alloc;
6412           switches_debug_check[0] = switches;
6413
6414           n_switches = n_switches_debug_check[1];
6415           n_switches_alloc = n_switches_alloc_debug_check[1];
6416           switches = switches_debug_check[1];
6417         }
6418
6419       /* Avoid crash when computing %j in this early.  */
6420       save = save_temps_flag;
6421       save_temps_flag = SAVE_TEMPS_NONE;
6422
6423       compare_debug = -compare_debug;
6424       do_self_spec ("%:compare-debug-self-opt()");
6425
6426       save_temps_flag = save;
6427
6428       if (!compare_debug_second)
6429         {
6430           n_switches_debug_check[1] = n_switches;
6431           n_switches_alloc_debug_check[1] = n_switches_alloc;
6432           switches_debug_check[1] = switches;
6433           compare_debug = -compare_debug;
6434           n_switches = n_switches_debug_check[0];
6435           n_switches_alloc = n_switches_debug_check[0];
6436           switches = switches_debug_check[0];
6437         }
6438     }
6439
6440
6441   /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake.  */
6442   if (gcc_exec_prefix)
6443     gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
6444                               spec_version, dir_separator_str, NULL);
6445
6446   /* Now we have the specs.
6447      Set the `valid' bits for switches that match anything in any spec.  */
6448
6449   validate_all_switches ();
6450
6451   /* Now that we have the switches and the specs, set
6452      the subdirectory based on the options.  */
6453   set_multilib_dir ();
6454
6455   /* Set up to remember the pathname of gcc and any options
6456      needed for collect.  We use argv[0] instead of progname because
6457      we need the complete pathname.  */
6458   obstack_init (&collect_obstack);
6459   obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6460   obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
6461   xputenv (XOBFINISH (&collect_obstack, char *));
6462
6463   /* Set up to remember the pathname of the lto wrapper. */
6464
6465   if (have_c)
6466     lto_wrapper_file = NULL;
6467   else
6468     lto_wrapper_file = find_a_file (&exec_prefixes, "lto-wrapper",
6469                                     X_OK, false);
6470   if (lto_wrapper_file)
6471     {
6472       lto_wrapper_spec = lto_wrapper_file;
6473       obstack_init (&collect_obstack);
6474       obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
6475                     sizeof ("COLLECT_LTO_WRAPPER=") - 1);
6476       obstack_grow (&collect_obstack, lto_wrapper_spec,
6477                     strlen (lto_wrapper_spec) + 1);
6478       xputenv (XOBFINISH (&collect_obstack, char *));
6479     }
6480
6481   /* Warn about any switches that no pass was interested in.  */
6482
6483   for (i = 0; (int) i < n_switches; i++)
6484     if (! switches[i].validated)
6485       error ("unrecognized option %<-%s%>", switches[i].part1);
6486
6487   /* Obey some of the options.  */
6488
6489   if (print_search_dirs)
6490     {
6491       printf (_("install: %s%s\n"),
6492               gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
6493               gcc_exec_prefix ? "" : machine_suffix);
6494       printf (_("programs: %s\n"),
6495               build_search_list (&exec_prefixes, "", false, false));
6496       printf (_("libraries: %s\n"),
6497               build_search_list (&startfile_prefixes, "", false, true));
6498       return (0);
6499     }
6500
6501   if (print_file_name)
6502     {
6503       printf ("%s\n", find_file (print_file_name));
6504       return (0);
6505     }
6506
6507   if (print_prog_name)
6508     {
6509       char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
6510       printf ("%s\n", (newname ? newname : print_prog_name));
6511       return (0);
6512     }
6513
6514   if (print_multi_lib)
6515     {
6516       print_multilib_info ();
6517       return (0);
6518     }
6519
6520   if (print_multi_directory)
6521     {
6522       if (multilib_dir == NULL)
6523         printf (".\n");
6524       else
6525         printf ("%s\n", multilib_dir);
6526       return (0);
6527     }
6528
6529   if (print_sysroot)
6530     {
6531       if (target_system_root)
6532         {
6533           if (target_sysroot_suffix)
6534             printf ("%s%s\n", target_system_root, target_sysroot_suffix);
6535           else
6536             printf ("%s\n", target_system_root);
6537         }
6538       return (0);
6539     }
6540
6541   if (print_multi_os_directory)
6542     {
6543       if (multilib_os_dir == NULL)
6544         printf (".\n");
6545       else
6546         printf ("%s\n", multilib_os_dir);
6547       return (0);
6548     }
6549
6550   if (print_sysroot_headers_suffix)
6551     {
6552       if (*sysroot_hdrs_suffix_spec)
6553         {
6554           printf("%s\n", (target_sysroot_hdrs_suffix
6555                           ? target_sysroot_hdrs_suffix
6556                           : ""));
6557           return (0);
6558         }
6559       else
6560         /* The error status indicates that only one set of fixed
6561            headers should be built.  */
6562         fatal_error ("not configured with sysroot headers suffix");
6563     }
6564
6565   if (print_help_list)
6566     {
6567       display_help ();
6568
6569       if (! verbose_flag)
6570         {
6571           printf (_("\nFor bug reporting instructions, please see:\n"));
6572           printf ("%s.\n", bug_report_url);
6573
6574           return (0);
6575         }
6576
6577       /* We do not exit here.  Instead we have created a fake input file
6578          called 'help-dummy' which needs to be compiled, and we pass this
6579          on the various sub-processes, along with the --help switch.
6580          Ensure their output appears after ours.  */
6581       fputc ('\n', stdout);
6582       fflush (stdout);
6583     }
6584
6585   if (print_version)
6586     {
6587       printf (_("%s %s%s\n"), progname, pkgversion_string,
6588               version_string);
6589       printf ("Copyright %s 2012 Free Software Foundation, Inc.\n",
6590               _("(C)"));
6591       fputs (_("This is free software; see the source for copying conditions.  There is NO\n\
6592 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
6593              stdout);
6594       if (! verbose_flag)
6595         return 0;
6596
6597       /* We do not exit here. We use the same mechanism of --help to print
6598          the version of the sub-processes. */
6599       fputc ('\n', stdout);
6600       fflush (stdout);
6601     }
6602
6603   if (verbose_flag)
6604     {
6605       int n;
6606       const char *thrmod;
6607
6608       fnotice (stderr, "Target: %s\n", spec_machine);
6609       fnotice (stderr, "Configured with: %s\n", configuration_arguments);
6610
6611 #ifdef THREAD_MODEL_SPEC
6612       /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6613          but there's no point in doing all this processing just to get
6614          thread_model back.  */
6615       obstack_init (&obstack);
6616       do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
6617       obstack_1grow (&obstack, '\0');
6618       thrmod = XOBFINISH (&obstack, const char *);
6619 #else
6620       thrmod = thread_model;
6621 #endif
6622
6623       fnotice (stderr, "Thread model: %s\n", thrmod);
6624
6625       /* compiler_version is truncated at the first space when initialized
6626          from version string, so truncate version_string at the first space
6627          before comparing.  */
6628       for (n = 0; version_string[n]; n++)
6629         if (version_string[n] == ' ')
6630           break;
6631
6632       if (! strncmp (version_string, compiler_version, n)
6633           && compiler_version[n] == 0)
6634         fnotice (stderr, "gcc version %s %s\n", version_string,
6635                  pkgversion_string);
6636       else
6637         fnotice (stderr, "gcc driver version %s %sexecuting gcc version %s\n",
6638                  version_string, pkgversion_string, compiler_version);
6639
6640       if (n_infiles == 0)
6641         return (0);
6642     }
6643
6644   if (n_infiles == added_libraries)
6645     fatal_error ("no input files");
6646
6647   if (seen_error ())
6648     goto out;
6649
6650   /* Make a place to record the compiler output file names
6651      that correspond to the input files.  */
6652
6653   i = n_infiles;
6654   i += lang_specific_extra_outfiles;
6655   outfiles = XCNEWVEC (const char *, i);
6656
6657   /* Record which files were specified explicitly as link input.  */
6658
6659   explicit_link_files = XCNEWVEC (char, n_infiles);
6660
6661   combine_inputs = have_o || flag_wpa;
6662
6663   for (i = 0; (int) i < n_infiles; i++)
6664     {
6665       const char *name = infiles[i].name;
6666       struct compiler *compiler = lookup_compiler (name,
6667                                                    strlen (name),
6668                                                    infiles[i].language);
6669
6670       if (compiler && !(compiler->combinable))
6671         combine_inputs = false;
6672
6673       if (lang_n_infiles > 0 && compiler != input_file_compiler
6674           && infiles[i].language && infiles[i].language[0] != '*')
6675         infiles[i].incompiler = compiler;
6676       else if (compiler)
6677         {
6678           lang_n_infiles++;
6679           input_file_compiler = compiler;
6680           infiles[i].incompiler = compiler;
6681         }
6682       else
6683         {
6684           /* Since there is no compiler for this input file, assume it is a
6685              linker file.  */
6686           explicit_link_files[i] = 1;
6687           infiles[i].incompiler = NULL;
6688         }
6689       infiles[i].compiled = false;
6690       infiles[i].preprocessed = false;
6691     }
6692
6693   if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
6694     fatal_error ("cannot specify -o with -c, -S or -E with multiple files");
6695
6696   for (i = 0; (int) i < n_infiles; i++)
6697     {
6698       int this_file_error = 0;
6699
6700       /* Tell do_spec what to substitute for %i.  */
6701
6702       input_file_number = i;
6703       set_input (infiles[i].name);
6704
6705       if (infiles[i].compiled)
6706         continue;
6707
6708       /* Use the same thing in %o, unless cp->spec says otherwise.  */
6709
6710       outfiles[i] = gcc_input_filename;
6711
6712       /* Figure out which compiler from the file's suffix.  */
6713
6714       input_file_compiler
6715         = lookup_compiler (infiles[i].name, input_filename_length,
6716                            infiles[i].language);
6717
6718       if (input_file_compiler)
6719         {
6720           /* Ok, we found an applicable compiler.  Run its spec.  */
6721
6722           if (input_file_compiler->spec[0] == '#')
6723             {
6724               error ("%s: %s compiler not installed on this system",
6725                      gcc_input_filename, &input_file_compiler->spec[1]);
6726               this_file_error = 1;
6727             }
6728           else
6729             {
6730               if (compare_debug)
6731                 {
6732                   free (debug_check_temp_file[0]);
6733                   debug_check_temp_file[0] = NULL;
6734
6735                   free (debug_check_temp_file[1]);
6736                   debug_check_temp_file[1] = NULL;
6737                 }
6738
6739               value = do_spec (input_file_compiler->spec);
6740               infiles[i].compiled = true;
6741               if (value < 0)
6742                 this_file_error = 1;
6743               else if (compare_debug && debug_check_temp_file[0])
6744                 {
6745                   if (verbose_flag)
6746                     inform (0, "recompiling with -fcompare-debug");
6747
6748                   compare_debug = -compare_debug;
6749                   n_switches = n_switches_debug_check[1];
6750                   n_switches_alloc = n_switches_alloc_debug_check[1];
6751                   switches = switches_debug_check[1];
6752
6753                   value = do_spec (input_file_compiler->spec);
6754
6755                   compare_debug = -compare_debug;
6756                   n_switches = n_switches_debug_check[0];
6757                   n_switches_alloc = n_switches_alloc_debug_check[0];
6758                   switches = switches_debug_check[0];
6759
6760                   if (value < 0)
6761                     {
6762                       error ("during -fcompare-debug recompilation");
6763                       this_file_error = 1;
6764                     }
6765
6766                   gcc_assert (debug_check_temp_file[1]
6767                               && filename_cmp (debug_check_temp_file[0],
6768                                                debug_check_temp_file[1]));
6769
6770                   if (verbose_flag)
6771                     inform (0, "comparing final insns dumps");
6772
6773                   if (compare_files (debug_check_temp_file))
6774                     this_file_error = 1;
6775                 }
6776
6777               if (compare_debug)
6778                 {
6779                   free (debug_check_temp_file[0]);
6780                   debug_check_temp_file[0] = NULL;
6781
6782                   free (debug_check_temp_file[1]);
6783                   debug_check_temp_file[1] = NULL;
6784                 }
6785             }
6786         }
6787
6788       /* If this file's name does not contain a recognized suffix,
6789          record it as explicit linker input.  */
6790
6791       else
6792         explicit_link_files[i] = 1;
6793
6794       /* Clear the delete-on-failure queue, deleting the files in it
6795          if this compilation failed.  */
6796
6797       if (this_file_error)
6798         {
6799           delete_failure_queue ();
6800           errorcount++;
6801         }
6802       /* If this compilation succeeded, don't delete those files later.  */
6803       clear_failure_queue ();
6804     }
6805
6806   /* Reset the input file name to the first compile/object file name, for use
6807      with %b in LINK_SPEC. We use the first input file that we can find
6808      a compiler to compile it instead of using infiles.language since for
6809      languages other than C we use aliases that we then lookup later.  */
6810   if (n_infiles > 0)
6811     {
6812       int i;
6813
6814       for (i = 0; i < n_infiles ; i++)
6815         if (infiles[i].incompiler
6816             || (infiles[i].language && infiles[i].language[0] != '*'))
6817           {
6818             set_input (infiles[i].name);
6819             break;
6820           }
6821     }
6822
6823   if (!seen_error ())
6824     {
6825       /* Make sure INPUT_FILE_NUMBER points to first available open
6826          slot.  */
6827       input_file_number = n_infiles;
6828       if (lang_specific_pre_link ())
6829         errorcount++;
6830     }
6831
6832   /* Determine if there are any linker input files.  */
6833   num_linker_inputs = 0;
6834   for (i = 0; (int) i < n_infiles; i++)
6835     if (explicit_link_files[i] || outfiles[i] != NULL)
6836       num_linker_inputs++;
6837
6838   /* Run ld to link all the compiler output files.  */
6839
6840   if (num_linker_inputs > 0 && !seen_error () && print_subprocess_help < 2)
6841     {
6842       int tmp = execution_count;
6843
6844       if (! have_c)
6845         {
6846 #if HAVE_LTO_PLUGIN > 0
6847 #if HAVE_LTO_PLUGIN == 2
6848           const char *fno_use_linker_plugin = "fno-use-linker-plugin";
6849 #else
6850           const char *fuse_linker_plugin = "fuse-linker-plugin";
6851 #endif
6852 #endif
6853
6854           /* We'll use ld if we can't find collect2.  */
6855           if (! strcmp (linker_name_spec, "collect2"))
6856             {
6857               char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
6858               if (s == NULL)
6859                 linker_name_spec = "ld";
6860             }
6861
6862 #if HAVE_LTO_PLUGIN > 0
6863 #if HAVE_LTO_PLUGIN == 2
6864           if (!switch_matches (fno_use_linker_plugin,
6865                                fno_use_linker_plugin
6866                                + strlen (fno_use_linker_plugin), 0))
6867 #else
6868           if (switch_matches (fuse_linker_plugin,
6869                               fuse_linker_plugin
6870                               + strlen (fuse_linker_plugin), 0))
6871 #endif
6872             {
6873               linker_plugin_file_spec = find_a_file (&exec_prefixes,
6874                                                      LTOPLUGINSONAME, R_OK,
6875                                                      false);
6876               if (!linker_plugin_file_spec)
6877                 fatal_error ("-fuse-linker-plugin, but %s not found",
6878                              LTOPLUGINSONAME);
6879             }
6880 #endif
6881           lto_gcc_spec = argv[0];
6882         }
6883
6884       /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
6885          for collect.  */
6886       putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
6887       putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
6888
6889       if (print_subprocess_help == 1)
6890         {
6891           printf (_("\nLinker options\n==============\n\n"));
6892           printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
6893                     " to the linker.\n\n"));
6894           fflush (stdout);
6895         }
6896       value = do_spec (link_command_spec);
6897       if (value < 0)
6898         errorcount = 1;
6899       linker_was_run = (tmp != execution_count);
6900     }
6901
6902   /* If options said don't run linker,
6903      complain about input files to be given to the linker.  */
6904
6905   if (! linker_was_run && !seen_error ())
6906     for (i = 0; (int) i < n_infiles; i++)
6907       if (explicit_link_files[i]
6908           && !(infiles[i].language && infiles[i].language[0] == '*'))
6909         warning (0, "%s: linker input file unused because linking not done",
6910                  outfiles[i]);
6911
6912   /* Delete some or all of the temporary files we made.  */
6913
6914   if (seen_error ())
6915     delete_failure_queue ();
6916   delete_temp_files ();
6917
6918   if (print_help_list)
6919     {
6920       printf (("\nFor bug reporting instructions, please see:\n"));
6921       printf ("%s\n", bug_report_url);
6922     }
6923
6924  out:
6925   return (signal_count != 0 ? 2
6926           : seen_error () ? (pass_exit_codes ? greatest_status : 1)
6927           : 0);
6928 }
6929
6930 /* Find the proper compilation spec for the file name NAME,
6931    whose length is LENGTH.  LANGUAGE is the specified language,
6932    or 0 if this file is to be passed to the linker.  */
6933
6934 static struct compiler *
6935 lookup_compiler (const char *name, size_t length, const char *language)
6936 {
6937   struct compiler *cp;
6938
6939   /* If this was specified by the user to be a linker input, indicate that.  */
6940   if (language != 0 && language[0] == '*')
6941     return 0;
6942
6943   /* Otherwise, look for the language, if one is spec'd.  */
6944   if (language != 0)
6945     {
6946       for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6947         if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
6948           return cp;
6949
6950       error ("language %s not recognized", language);
6951       return 0;
6952     }
6953
6954   /* Look for a suffix.  */
6955   for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6956     {
6957       if (/* The suffix `-' matches only the file name `-'.  */
6958           (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
6959           || (strlen (cp->suffix) < length
6960               /* See if the suffix matches the end of NAME.  */
6961               && !strcmp (cp->suffix,
6962                           name + length - strlen (cp->suffix))
6963          ))
6964         break;
6965     }
6966
6967 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
6968   /* Look again, but case-insensitively this time.  */
6969   if (cp < compilers)
6970     for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6971       {
6972         if (/* The suffix `-' matches only the file name `-'.  */
6973             (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
6974             || (strlen (cp->suffix) < length
6975                 /* See if the suffix matches the end of NAME.  */
6976                 && ((!strcmp (cp->suffix,
6977                              name + length - strlen (cp->suffix))
6978                      || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
6979                     && !strcasecmp (cp->suffix,
6980                                     name + length - strlen (cp->suffix)))
6981            ))
6982           break;
6983       }
6984 #endif
6985
6986   if (cp >= compilers)
6987     {
6988       if (cp->spec[0] != '@')
6989         /* A non-alias entry: return it.  */
6990         return cp;
6991
6992       /* An alias entry maps a suffix to a language.
6993          Search for the language; pass 0 for NAME and LENGTH
6994          to avoid infinite recursion if language not found.  */
6995       return lookup_compiler (NULL, 0, cp->spec + 1);
6996     }
6997   return 0;
6998 }
6999 \f
7000 static char *
7001 save_string (const char *s, int len)
7002 {
7003   char *result = XNEWVEC (char, len + 1);
7004
7005   memcpy (result, s, len);
7006   result[len] = 0;
7007   return result;
7008 }
7009
7010 void
7011 pfatal_with_name (const char *name)
7012 {
7013   perror_with_name (name);
7014   delete_temp_files ();
7015   exit (1);
7016 }
7017
7018 static void
7019 perror_with_name (const char *name)
7020 {
7021   error ("%s: %m", name);
7022 }
7023 \f
7024 static inline void
7025 validate_switches_from_spec (const char *spec)
7026 {
7027   const char *p = spec;
7028   char c;
7029   while ((c = *p++))
7030     if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
7031       /* We have a switch spec.  */
7032       p = validate_switches (p + 1);
7033 }
7034
7035 static void
7036 validate_all_switches (void)
7037 {
7038   struct compiler *comp;
7039   struct spec_list *spec;
7040
7041   for (comp = compilers; comp->spec; comp++)
7042     validate_switches_from_spec (comp->spec);
7043
7044   /* Look through the linked list of specs read from the specs file.  */
7045   for (spec = specs; spec; spec = spec->next)
7046     validate_switches_from_spec (*spec->ptr_spec);
7047
7048   validate_switches_from_spec (link_command_spec);
7049 }
7050
7051 /* Look at the switch-name that comes after START
7052    and mark as valid all supplied switches that match it.  */
7053
7054 static const char *
7055 validate_switches (const char *start)
7056 {
7057   const char *p = start;
7058   const char *atom;
7059   size_t len;
7060   int i;
7061   bool suffix = false;
7062   bool starred = false;
7063
7064 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7065
7066 next_member:
7067   SKIP_WHITE ();
7068
7069   if (*p == '!')
7070     p++;
7071
7072   SKIP_WHITE ();
7073   if (*p == '.' || *p == ',')
7074     suffix = true, p++;
7075
7076   atom = p;
7077   while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7078          || *p == ',' || *p == '.' || *p == '@')
7079     p++;
7080   len = p - atom;
7081
7082   if (*p == '*')
7083     starred = true, p++;
7084
7085   SKIP_WHITE ();
7086
7087   if (!suffix)
7088     {
7089       /* Mark all matching switches as valid.  */
7090       for (i = 0; i < n_switches; i++)
7091         if (!strncmp (switches[i].part1, atom, len)
7092             && (starred || switches[i].part1[len] == 0))
7093           switches[i].validated = 1;
7094     }
7095
7096   if (*p) p++;
7097   if (*p && (p[-1] == '|' || p[-1] == '&'))
7098     goto next_member;
7099
7100   if (*p && p[-1] == ':')
7101     {
7102       while (*p && *p != ';' && *p != '}')
7103         {
7104           if (*p == '%')
7105             {
7106               p++;
7107               if (*p == '{' || *p == '<')
7108                 p = validate_switches (p+1);
7109               else if (p[0] == 'W' && p[1] == '{')
7110                 p = validate_switches (p+2);
7111             }
7112           else
7113             p++;
7114         }
7115
7116       if (*p) p++;
7117       if (*p && p[-1] == ';')
7118         goto next_member;
7119     }
7120
7121   return p;
7122 #undef SKIP_WHITE
7123 }
7124 \f
7125 struct mdswitchstr
7126 {
7127   const char *str;
7128   int len;
7129 };
7130
7131 static struct mdswitchstr *mdswitches;
7132 static int n_mdswitches;
7133
7134 /* Check whether a particular argument was used.  The first time we
7135    canonicalize the switches to keep only the ones we care about.  */
7136
7137 static int
7138 used_arg (const char *p, int len)
7139 {
7140   struct mswitchstr
7141   {
7142     const char *str;
7143     const char *replace;
7144     int len;
7145     int rep_len;
7146   };
7147
7148   static struct mswitchstr *mswitches;
7149   static int n_mswitches;
7150   int i, j;
7151
7152   if (!mswitches)
7153     {
7154       struct mswitchstr *matches;
7155       const char *q;
7156       int cnt = 0;
7157
7158       /* Break multilib_matches into the component strings of string
7159          and replacement string.  */
7160       for (q = multilib_matches; *q != '\0'; q++)
7161         if (*q == ';')
7162           cnt++;
7163
7164       matches
7165         = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
7166       i = 0;
7167       q = multilib_matches;
7168       while (*q != '\0')
7169         {
7170           matches[i].str = q;
7171           while (*q != ' ')
7172             {
7173               if (*q == '\0')
7174                 {
7175                 invalid_matches:
7176                   fatal_error ("multilib spec %qs is invalid",
7177                                multilib_matches);
7178                 }
7179               q++;
7180             }
7181           matches[i].len = q - matches[i].str;
7182
7183           matches[i].replace = ++q;
7184           while (*q != ';' && *q != '\0')
7185             {
7186               if (*q == ' ')
7187                 goto invalid_matches;
7188               q++;
7189             }
7190           matches[i].rep_len = q - matches[i].replace;
7191           i++;
7192           if (*q == ';')
7193             q++;
7194         }
7195
7196       /* Now build a list of the replacement string for switches that we care
7197          about.  Make sure we allocate at least one entry.  This prevents
7198          xmalloc from calling fatal, and prevents us from re-executing this
7199          block of code.  */
7200       mswitches
7201         = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
7202       for (i = 0; i < n_switches; i++)
7203         if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
7204           {
7205             int xlen = strlen (switches[i].part1);
7206             for (j = 0; j < cnt; j++)
7207               if (xlen == matches[j].len
7208                   && ! strncmp (switches[i].part1, matches[j].str, xlen))
7209                 {
7210                   mswitches[n_mswitches].str = matches[j].replace;
7211                   mswitches[n_mswitches].len = matches[j].rep_len;
7212                   mswitches[n_mswitches].replace = (char *) 0;
7213                   mswitches[n_mswitches].rep_len = 0;
7214                   n_mswitches++;
7215                   break;
7216                 }
7217           }
7218
7219       /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7220          on the command line nor any options mutually incompatible with
7221          them.  */
7222       for (i = 0; i < n_mdswitches; i++)
7223         {
7224           const char *r;
7225
7226           for (q = multilib_options; *q != '\0'; q++)
7227             {
7228               while (*q == ' ')
7229                 q++;
7230
7231               r = q;
7232               while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
7233                      || strchr (" /", q[mdswitches[i].len]) == NULL)
7234                 {
7235                   while (*q != ' ' && *q != '/' && *q != '\0')
7236                     q++;
7237                   if (*q != '/')
7238                     break;
7239                   q++;
7240                 }
7241
7242               if (*q != ' ' && *q != '\0')
7243                 {
7244                   while (*r != ' ' && *r != '\0')
7245                     {
7246                       q = r;
7247                       while (*q != ' ' && *q != '/' && *q != '\0')
7248                         q++;
7249
7250                       if (used_arg (r, q - r))
7251                         break;
7252
7253                       if (*q != '/')
7254                         {
7255                           mswitches[n_mswitches].str = mdswitches[i].str;
7256                           mswitches[n_mswitches].len = mdswitches[i].len;
7257                           mswitches[n_mswitches].replace = (char *) 0;
7258                           mswitches[n_mswitches].rep_len = 0;
7259                           n_mswitches++;
7260                           break;
7261                         }
7262
7263                       r = q + 1;
7264                     }
7265                   break;
7266                 }
7267             }
7268         }
7269     }
7270
7271   for (i = 0; i < n_mswitches; i++)
7272     if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
7273       return 1;
7274
7275   return 0;
7276 }
7277
7278 static int
7279 default_arg (const char *p, int len)
7280 {
7281   int i;
7282
7283   for (i = 0; i < n_mdswitches; i++)
7284     if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
7285       return 1;
7286
7287   return 0;
7288 }
7289
7290 /* Work out the subdirectory to use based on the options. The format of
7291    multilib_select is a list of elements. Each element is a subdirectory
7292    name followed by a list of options followed by a semicolon. The format
7293    of multilib_exclusions is the same, but without the preceding
7294    directory. First gcc will check the exclusions, if none of the options
7295    beginning with an exclamation point are present, and all of the other
7296    options are present, then we will ignore this completely. Passing
7297    that, gcc will consider each multilib_select in turn using the same
7298    rules for matching the options. If a match is found, that subdirectory
7299    will be used.  */
7300
7301 static void
7302 set_multilib_dir (void)
7303 {
7304   const char *p;
7305   unsigned int this_path_len;
7306   const char *this_path, *this_arg;
7307   const char *start, *end;
7308   int not_arg;
7309   int ok, ndfltok, first;
7310
7311   n_mdswitches = 0;
7312   start = multilib_defaults;
7313   while (*start == ' ' || *start == '\t')
7314     start++;
7315   while (*start != '\0')
7316     {
7317       n_mdswitches++;
7318       while (*start != ' ' && *start != '\t' && *start != '\0')
7319         start++;
7320       while (*start == ' ' || *start == '\t')
7321         start++;
7322     }
7323
7324   if (n_mdswitches)
7325     {
7326       int i = 0;
7327
7328       mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
7329       for (start = multilib_defaults; *start != '\0'; start = end + 1)
7330         {
7331           while (*start == ' ' || *start == '\t')
7332             start++;
7333
7334           if (*start == '\0')
7335             break;
7336
7337           for (end = start + 1;
7338                *end != ' ' && *end != '\t' && *end != '\0'; end++)
7339             ;
7340
7341           obstack_grow (&multilib_obstack, start, end - start);
7342           obstack_1grow (&multilib_obstack, 0);
7343           mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
7344           mdswitches[i++].len = end - start;
7345
7346           if (*end == '\0')
7347             break;
7348         }
7349     }
7350
7351   p = multilib_exclusions;
7352   while (*p != '\0')
7353     {
7354       /* Ignore newlines.  */
7355       if (*p == '\n')
7356         {
7357           ++p;
7358           continue;
7359         }
7360
7361       /* Check the arguments.  */
7362       ok = 1;
7363       while (*p != ';')
7364         {
7365           if (*p == '\0')
7366             {
7367             invalid_exclusions:
7368               fatal_error ("multilib exclusions %qs is invalid",
7369                            multilib_exclusions);
7370             }
7371
7372           if (! ok)
7373             {
7374               ++p;
7375               continue;
7376             }
7377
7378           this_arg = p;
7379           while (*p != ' ' && *p != ';')
7380             {
7381               if (*p == '\0')
7382                 goto invalid_exclusions;
7383               ++p;
7384             }
7385
7386           if (*this_arg != '!')
7387             not_arg = 0;
7388           else
7389             {
7390               not_arg = 1;
7391               ++this_arg;
7392             }
7393
7394           ok = used_arg (this_arg, p - this_arg);
7395           if (not_arg)
7396             ok = ! ok;
7397
7398           if (*p == ' ')
7399             ++p;
7400         }
7401
7402       if (ok)
7403         return;
7404
7405       ++p;
7406     }
7407
7408   first = 1;
7409   p = multilib_select;
7410   while (*p != '\0')
7411     {
7412       /* Ignore newlines.  */
7413       if (*p == '\n')
7414         {
7415           ++p;
7416           continue;
7417         }
7418
7419       /* Get the initial path.  */
7420       this_path = p;
7421       while (*p != ' ')
7422         {
7423           if (*p == '\0')
7424             {
7425             invalid_select:
7426               fatal_error ("multilib select %qs is invalid",
7427                            multilib_select);
7428             }
7429           ++p;
7430         }
7431       this_path_len = p - this_path;
7432
7433       /* Check the arguments.  */
7434       ok = 1;
7435       ndfltok = 1;
7436       ++p;
7437       while (*p != ';')
7438         {
7439           if (*p == '\0')
7440             goto invalid_select;
7441
7442           if (! ok)
7443             {
7444               ++p;
7445               continue;
7446             }
7447
7448           this_arg = p;
7449           while (*p != ' ' && *p != ';')
7450             {
7451               if (*p == '\0')
7452                 goto invalid_select;
7453               ++p;
7454             }
7455
7456           if (*this_arg != '!')
7457             not_arg = 0;
7458           else
7459             {
7460               not_arg = 1;
7461               ++this_arg;
7462             }
7463
7464           /* If this is a default argument, we can just ignore it.
7465              This is true even if this_arg begins with '!'.  Beginning
7466              with '!' does not mean that this argument is necessarily
7467              inappropriate for this library: it merely means that
7468              there is a more specific library which uses this
7469              argument.  If this argument is a default, we need not
7470              consider that more specific library.  */
7471           ok = used_arg (this_arg, p - this_arg);
7472           if (not_arg)
7473             ok = ! ok;
7474
7475           if (! ok)
7476             ndfltok = 0;
7477
7478           if (default_arg (this_arg, p - this_arg))
7479             ok = 1;
7480
7481           if (*p == ' ')
7482             ++p;
7483         }
7484
7485       if (ok && first)
7486         {
7487           if (this_path_len != 1
7488               || this_path[0] != '.')
7489             {
7490               char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
7491               char *q;
7492
7493               strncpy (new_multilib_dir, this_path, this_path_len);
7494               new_multilib_dir[this_path_len] = '\0';
7495               q = strchr (new_multilib_dir, ':');
7496               if (q != NULL)
7497                 *q = '\0';
7498               multilib_dir = new_multilib_dir;
7499             }
7500           first = 0;
7501         }
7502
7503       if (ndfltok)
7504         {
7505           const char *q = this_path, *end = this_path + this_path_len;
7506
7507           while (q < end && *q != ':')
7508             q++;
7509           if (q < end)
7510             {
7511               char *new_multilib_os_dir = XNEWVEC (char, end - q);
7512               memcpy (new_multilib_os_dir, q + 1, end - q - 1);
7513               new_multilib_os_dir[end - q - 1] = '\0';
7514               multilib_os_dir = new_multilib_os_dir;
7515               break;
7516             }
7517         }
7518
7519       ++p;
7520     }
7521
7522   if (multilib_dir == NULL && multilib_os_dir != NULL
7523       && strcmp (multilib_os_dir, ".") == 0)
7524     {
7525       free (CONST_CAST (char *, multilib_os_dir));
7526       multilib_os_dir = NULL;
7527     }
7528   else if (multilib_dir != NULL && multilib_os_dir == NULL)
7529     multilib_os_dir = multilib_dir;
7530 }
7531
7532 /* Print out the multiple library subdirectory selection
7533    information.  This prints out a series of lines.  Each line looks
7534    like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7535    required.  Only the desired options are printed out, the negative
7536    matches.  The options are print without a leading dash.  There are
7537    no spaces to make it easy to use the information in the shell.
7538    Each subdirectory is printed only once.  This assumes the ordering
7539    generated by the genmultilib script. Also, we leave out ones that match
7540    the exclusions.  */
7541
7542 static void
7543 print_multilib_info (void)
7544 {
7545   const char *p = multilib_select;
7546   const char *last_path = 0, *this_path;
7547   int skip;
7548   unsigned int last_path_len = 0;
7549
7550   while (*p != '\0')
7551     {
7552       skip = 0;
7553       /* Ignore newlines.  */
7554       if (*p == '\n')
7555         {
7556           ++p;
7557           continue;
7558         }
7559
7560       /* Get the initial path.  */
7561       this_path = p;
7562       while (*p != ' ')
7563         {
7564           if (*p == '\0')
7565             {
7566             invalid_select:
7567               fatal_error ("multilib select %qs is invalid", multilib_select);
7568             }
7569
7570           ++p;
7571         }
7572
7573       /* When --disable-multilib was used but target defines
7574          MULTILIB_OSDIRNAMES, entries starting with .: are there just
7575          to find multilib_os_dir, so skip them from output.  */
7576       if (this_path[0] == '.' && this_path[1] == ':')
7577         skip = 1;
7578
7579       /* Check for matches with the multilib_exclusions. We don't bother
7580          with the '!' in either list. If any of the exclusion rules match
7581          all of its options with the select rule, we skip it.  */
7582       {
7583         const char *e = multilib_exclusions;
7584         const char *this_arg;
7585
7586         while (*e != '\0')
7587           {
7588             int m = 1;
7589             /* Ignore newlines.  */
7590             if (*e == '\n')
7591               {
7592                 ++e;
7593                 continue;
7594               }
7595
7596             /* Check the arguments.  */
7597             while (*e != ';')
7598               {
7599                 const char *q;
7600                 int mp = 0;
7601
7602                 if (*e == '\0')
7603                   {
7604                   invalid_exclusion:
7605                     fatal_error ("multilib exclusion %qs is invalid",
7606                                  multilib_exclusions);
7607                   }
7608
7609                 if (! m)
7610                   {
7611                     ++e;
7612                     continue;
7613                   }
7614
7615                 this_arg = e;
7616
7617                 while (*e != ' ' && *e != ';')
7618                   {
7619                     if (*e == '\0')
7620                       goto invalid_exclusion;
7621                     ++e;
7622                   }
7623
7624                 q = p + 1;
7625                 while (*q != ';')
7626                   {
7627                     const char *arg;
7628                     int len = e - this_arg;
7629
7630                     if (*q == '\0')
7631                       goto invalid_select;
7632
7633                     arg = q;
7634
7635                     while (*q != ' ' && *q != ';')
7636                       {
7637                         if (*q == '\0')
7638                           goto invalid_select;
7639                         ++q;
7640                       }
7641
7642                     if (! strncmp (arg, this_arg,
7643                                    (len < q - arg) ? q - arg : len)
7644                         || default_arg (this_arg, e - this_arg))
7645                       {
7646                         mp = 1;
7647                         break;
7648                       }
7649
7650                     if (*q == ' ')
7651                       ++q;
7652                   }
7653
7654                 if (! mp)
7655                   m = 0;
7656
7657                 if (*e == ' ')
7658                   ++e;
7659               }
7660
7661             if (m)
7662               {
7663                 skip = 1;
7664                 break;
7665               }
7666
7667             if (*e != '\0')
7668               ++e;
7669           }
7670       }
7671
7672       if (! skip)
7673         {
7674           /* If this is a duplicate, skip it.  */
7675           skip = (last_path != 0
7676                   && (unsigned int) (p - this_path) == last_path_len
7677                   && ! filename_ncmp (last_path, this_path, last_path_len));
7678
7679           last_path = this_path;
7680           last_path_len = p - this_path;
7681         }
7682
7683       /* If this directory requires any default arguments, we can skip
7684          it.  We will already have printed a directory identical to
7685          this one which does not require that default argument.  */
7686       if (! skip)
7687         {
7688           const char *q;
7689
7690           q = p + 1;
7691           while (*q != ';')
7692             {
7693               const char *arg;
7694
7695               if (*q == '\0')
7696                 goto invalid_select;
7697
7698               if (*q == '!')
7699                 arg = NULL;
7700               else
7701                 arg = q;
7702
7703               while (*q != ' ' && *q != ';')
7704                 {
7705                   if (*q == '\0')
7706                     goto invalid_select;
7707                   ++q;
7708                 }
7709
7710               if (arg != NULL
7711                   && default_arg (arg, q - arg))
7712                 {
7713                   skip = 1;
7714                   break;
7715                 }
7716
7717               if (*q == ' ')
7718                 ++q;
7719             }
7720         }
7721
7722       if (! skip)
7723         {
7724           const char *p1;
7725
7726           for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
7727             putchar (*p1);
7728           putchar (';');
7729         }
7730
7731       ++p;
7732       while (*p != ';')
7733         {
7734           int use_arg;
7735
7736           if (*p == '\0')
7737             goto invalid_select;
7738
7739           if (skip)
7740             {
7741               ++p;
7742               continue;
7743             }
7744
7745           use_arg = *p != '!';
7746
7747           if (use_arg)
7748             putchar ('@');
7749
7750           while (*p != ' ' && *p != ';')
7751             {
7752               if (*p == '\0')
7753                 goto invalid_select;
7754               if (use_arg)
7755                 putchar (*p);
7756               ++p;
7757             }
7758
7759           if (*p == ' ')
7760             ++p;
7761         }
7762
7763       if (! skip)
7764         {
7765           /* If there are extra options, print them now.  */
7766           if (multilib_extra && *multilib_extra)
7767             {
7768               int print_at = TRUE;
7769               const char *q;
7770
7771               for (q = multilib_extra; *q != '\0'; q++)
7772                 {
7773                   if (*q == ' ')
7774                     print_at = TRUE;
7775                   else
7776                     {
7777                       if (print_at)
7778                         putchar ('@');
7779                       putchar (*q);
7780                       print_at = FALSE;
7781                     }
7782                 }
7783             }
7784
7785           putchar ('\n');
7786         }
7787
7788       ++p;
7789     }
7790 }
7791 \f
7792 /* getenv built-in spec function.
7793
7794    Returns the value of the environment variable given by its first
7795    argument, concatenated with the second argument.  If the
7796    environment variable is not defined, a fatal error is issued.  */
7797
7798 static const char *
7799 getenv_spec_function (int argc, const char **argv)
7800 {
7801   char *value;
7802   char *result;
7803   char *ptr;
7804   size_t len;
7805
7806   if (argc != 2)
7807     return NULL;
7808
7809   value = getenv (argv[0]);
7810   if (!value)
7811     fatal_error ("environment variable %qs not defined", argv[0]);
7812
7813   /* We have to escape every character of the environment variable so
7814      they are not interpreted as active spec characters.  A
7815      particularly painful case is when we are reading a variable
7816      holding a windows path complete with \ separators.  */
7817   len = strlen (value) * 2 + strlen (argv[1]) + 1;
7818   result = XNEWVAR (char, len);
7819   for (ptr = result; *value; ptr += 2)
7820     {
7821       ptr[0] = '\\';
7822       ptr[1] = *value++;
7823     }
7824
7825   strcpy (ptr, argv[1]);
7826
7827   return result;
7828 }
7829
7830 /* if-exists built-in spec function.
7831
7832    Checks to see if the file specified by the absolute pathname in
7833    ARGS exists.  Returns that pathname if found.
7834
7835    The usual use for this function is to check for a library file
7836    (whose name has been expanded with %s).  */
7837
7838 static const char *
7839 if_exists_spec_function (int argc, const char **argv)
7840 {
7841   /* Must have only one argument.  */
7842   if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
7843     return argv[0];
7844
7845   return NULL;
7846 }
7847
7848 /* if-exists-else built-in spec function.
7849
7850    This is like if-exists, but takes an additional argument which
7851    is returned if the first argument does not exist.  */
7852
7853 static const char *
7854 if_exists_else_spec_function (int argc, const char **argv)
7855 {
7856   /* Must have exactly two arguments.  */
7857   if (argc != 2)
7858     return NULL;
7859
7860   if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
7861     return argv[0];
7862
7863   return argv[1];
7864 }
7865
7866 /* replace-outfile built-in spec function.
7867
7868    This looks for the first argument in the outfiles array's name and
7869    replaces it with the second argument.  */
7870
7871 static const char *
7872 replace_outfile_spec_function (int argc, const char **argv)
7873 {
7874   int i;
7875   /* Must have exactly two arguments.  */
7876   if (argc != 2)
7877     abort ();
7878
7879   for (i = 0; i < n_infiles; i++)
7880     {
7881       if (outfiles[i] && !filename_cmp (outfiles[i], argv[0]))
7882         outfiles[i] = xstrdup (argv[1]);
7883     }
7884   return NULL;
7885 }
7886
7887 /* remove-outfile built-in spec function.
7888  *
7889  *    This looks for the first argument in the outfiles array's name and
7890  *       removes it.  */
7891
7892 static const char *
7893 remove_outfile_spec_function (int argc, const char **argv)
7894 {
7895   int i;
7896   /* Must have exactly one argument.  */
7897   if (argc != 1)
7898     abort ();
7899
7900   for (i = 0; i < n_infiles; i++)
7901     {
7902       if (outfiles[i] && !filename_cmp (outfiles[i], argv[0]))
7903         outfiles[i] = NULL;
7904     }
7905   return NULL;
7906 }
7907
7908 /* Given two version numbers, compares the two numbers.
7909    A version number must match the regular expression
7910    ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
7911 */
7912 static int
7913 compare_version_strings (const char *v1, const char *v2)
7914 {
7915   int rresult;
7916   regex_t r;
7917
7918   if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
7919                REG_EXTENDED | REG_NOSUB) != 0)
7920     abort ();
7921   rresult = regexec (&r, v1, 0, NULL, 0);
7922   if (rresult == REG_NOMATCH)
7923     fatal_error ("invalid version number %qs", v1);
7924   else if (rresult != 0)
7925     abort ();
7926   rresult = regexec (&r, v2, 0, NULL, 0);
7927   if (rresult == REG_NOMATCH)
7928     fatal_error ("invalid version number %qs", v2);
7929   else if (rresult != 0)
7930     abort ();
7931
7932   return strverscmp (v1, v2);
7933 }
7934
7935
7936 /* version_compare built-in spec function.
7937
7938    This takes an argument of the following form:
7939
7940    <comparison-op> <arg1> [<arg2>] <switch> <result>
7941
7942    and produces "result" if the comparison evaluates to true,
7943    and nothing if it doesn't.
7944
7945    The supported <comparison-op> values are:
7946
7947    >=  true if switch is a later (or same) version than arg1
7948    !>  opposite of >=
7949    <   true if switch is an earlier version than arg1
7950    !<  opposite of <
7951    ><  true if switch is arg1 or later, and earlier than arg2
7952    <>  true if switch is earlier than arg1 or is arg2 or later
7953
7954    If the switch is not present, the condition is false unless
7955    the first character of the <comparison-op> is '!'.
7956
7957    For example,
7958    %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
7959    adds -lmx if -mmacosx-version-min=10.3.9 was passed.  */
7960
7961 static const char *
7962 version_compare_spec_function (int argc, const char **argv)
7963 {
7964   int comp1, comp2;
7965   size_t switch_len;
7966   const char *switch_value = NULL;
7967   int nargs = 1, i;
7968   bool result;
7969
7970   if (argc < 3)
7971     fatal_error ("too few arguments to %%:version-compare");
7972   if (argv[0][0] == '\0')
7973     abort ();
7974   if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
7975     nargs = 2;
7976   if (argc != nargs + 3)
7977     fatal_error ("too many arguments to %%:version-compare");
7978
7979   switch_len = strlen (argv[nargs + 1]);
7980   for (i = 0; i < n_switches; i++)
7981     if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
7982         && check_live_switch (i, switch_len))
7983       switch_value = switches[i].part1 + switch_len;
7984
7985   if (switch_value == NULL)
7986     comp1 = comp2 = -1;
7987   else
7988     {
7989       comp1 = compare_version_strings (switch_value, argv[1]);
7990       if (nargs == 2)
7991         comp2 = compare_version_strings (switch_value, argv[2]);
7992       else
7993         comp2 = -1;  /* This value unused.  */
7994     }
7995
7996   switch (argv[0][0] << 8 | argv[0][1])
7997     {
7998     case '>' << 8 | '=':
7999       result = comp1 >= 0;
8000       break;
8001     case '!' << 8 | '<':
8002       result = comp1 >= 0 || switch_value == NULL;
8003       break;
8004     case '<' << 8:
8005       result = comp1 < 0;
8006       break;
8007     case '!' << 8 | '>':
8008       result = comp1 < 0 || switch_value == NULL;
8009       break;
8010     case '>' << 8 | '<':
8011       result = comp1 >= 0 && comp2 < 0;
8012       break;
8013     case '<' << 8 | '>':
8014       result = comp1 < 0 || comp2 >= 0;
8015       break;
8016
8017     default:
8018       fatal_error ("unknown operator %qs in %%:version-compare", argv[0]);
8019     }
8020   if (! result)
8021     return NULL;
8022
8023   return argv[nargs + 2];
8024 }
8025
8026 /* %:include builtin spec function.  This differs from %include in that it
8027    can be nested inside a spec, and thus be conditionalized.  It takes
8028    one argument, the filename, and looks for it in the startfile path.
8029    The result is always NULL, i.e. an empty expansion.  */
8030
8031 static const char *
8032 include_spec_function (int argc, const char **argv)
8033 {
8034   char *file;
8035
8036   if (argc != 1)
8037     abort ();
8038
8039   file = find_a_file (&startfile_prefixes, argv[0], R_OK, true);
8040   read_specs (file ? file : argv[0], FALSE);
8041
8042   return NULL;
8043 }
8044
8045 /* %:find-file spec function.  This function replaces its argument by
8046     the file found thru find_file, that is the -print-file-name gcc
8047     program option. */
8048 static const char *
8049 find_file_spec_function (int argc, const char **argv)
8050 {
8051   const char *file;
8052
8053   if (argc != 1)
8054     abort ();
8055
8056   file = find_file (argv[0]);
8057   return file;
8058 }
8059
8060
8061 /* %:find-plugindir spec function.  This function replaces its argument
8062     by the -iplugindir=<dir> option.  `dir' is found thru find_file, that
8063     is the -print-file-name gcc program option. */
8064 static const char *
8065 find_plugindir_spec_function (int argc, const char **argv ATTRIBUTE_UNUSED)
8066 {
8067   const char *option;
8068
8069   if (argc != 0)
8070     abort ();
8071
8072   option = concat ("-iplugindir=", find_file ("plugin"), NULL);
8073   return option;
8074 }
8075
8076
8077 /* %:print-asm-header spec function.  Print a banner to say that the
8078    following output is from the assembler.  */
8079
8080 static const char *
8081 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
8082                                 const char **argv ATTRIBUTE_UNUSED)
8083 {
8084   printf (_("Assembler options\n=================\n\n"));
8085   printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8086   fflush (stdout);
8087   return NULL;
8088 }
8089
8090 /* Get a random number for -frandom-seed */
8091
8092 static unsigned HOST_WIDE_INT
8093 get_random_number (void)
8094 {
8095   unsigned HOST_WIDE_INT ret = 0;
8096   int fd;
8097
8098   fd = open ("/dev/urandom", O_RDONLY);
8099   if (fd >= 0)
8100     {
8101       read (fd, &ret, sizeof (HOST_WIDE_INT));
8102       close (fd);
8103       if (ret)
8104         return ret;
8105     }
8106
8107   /* Get some more or less random data.  */
8108 #ifdef HAVE_GETTIMEOFDAY
8109   {
8110     struct timeval tv;
8111
8112     gettimeofday (&tv, NULL);
8113     ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
8114   }
8115 #else
8116   {
8117     time_t now = time (NULL);
8118
8119     if (now != (time_t)-1)
8120       ret = (unsigned) now;
8121   }
8122 #endif
8123
8124   return ret ^ getpid();
8125 }
8126
8127 /* %:compare-debug-dump-opt spec function.  Save the last argument,
8128    expected to be the last -fdump-final-insns option, or generate a
8129    temporary.  */
8130
8131 static const char *
8132 compare_debug_dump_opt_spec_function (int arg,
8133                                       const char **argv ATTRIBUTE_UNUSED)
8134 {
8135   const char *ret;
8136   char *name;
8137   int which;
8138   static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
8139
8140   if (arg != 0)
8141     fatal_error ("too many arguments to %%:compare-debug-dump-opt");
8142
8143   do_spec_2 ("%{fdump-final-insns=*:%*}");
8144   do_spec_1 (" ", 0, NULL);
8145
8146   if (VEC_length (const_char_p, argbuf) > 0
8147       && strcmp (argv[VEC_length (const_char_p, argbuf) - 1], "."))
8148     {
8149       if (!compare_debug)
8150         return NULL;
8151
8152       name = xstrdup (argv[VEC_length (const_char_p, argbuf) - 1]);
8153       ret = NULL;
8154     }
8155   else
8156     {
8157       const char *ext = NULL;
8158
8159       if (VEC_length (const_char_p, argbuf) > 0)
8160         {
8161           do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8162           ext = ".gkd";
8163         }
8164       else if (!compare_debug)
8165         return NULL;
8166       else
8167         do_spec_2 ("%g.gkd");
8168
8169       do_spec_1 (" ", 0, NULL);
8170
8171       gcc_assert (VEC_length (const_char_p, argbuf) > 0);
8172
8173       name = concat (VEC_last (const_char_p, argbuf), ext, NULL);
8174
8175       ret = concat ("-fdump-final-insns=", name, NULL);
8176     }
8177
8178   which = compare_debug < 0;
8179   debug_check_temp_file[which] = name;
8180
8181   if (!which)
8182     {
8183       unsigned HOST_WIDE_INT value = get_random_number ();
8184
8185       sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
8186     }
8187
8188   if (*random_seed)
8189     ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
8190                   ret, NULL);
8191
8192   if (which)
8193     *random_seed = 0;
8194
8195   return ret;
8196 }
8197
8198 static const char *debug_auxbase_opt;
8199
8200 /* %:compare-debug-self-opt spec function.  Expands to the options
8201     that are to be passed in the second compilation of
8202     compare-debug.  */
8203
8204 static const char *
8205 compare_debug_self_opt_spec_function (int arg,
8206                                       const char **argv ATTRIBUTE_UNUSED)
8207 {
8208   if (arg != 0)
8209     fatal_error ("too many arguments to %%:compare-debug-self-opt");
8210
8211   if (compare_debug >= 0)
8212     return NULL;
8213
8214   do_spec_2 ("%{c|S:%{o*:%*}}");
8215   do_spec_1 (" ", 0, NULL);
8216
8217   if (VEC_length (const_char_p, argbuf) > 0)
8218     debug_auxbase_opt = concat ("-auxbase-strip ",
8219                                 VEC_last (const_char_p, argbuf),
8220                                 NULL);
8221   else
8222     debug_auxbase_opt = NULL;
8223
8224   return concat ("\
8225 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8226 %<fdump-final-insns=* -w -S -o %j \
8227 %{!fcompare-debug-second:-fcompare-debug-second} \
8228 ", compare_debug_opt, NULL);
8229 }
8230
8231 /* %:compare-debug-auxbase-opt spec function.  Expands to the auxbase
8232     options that are to be passed in the second compilation of
8233     compare-debug.  It expects, as an argument, the basename of the
8234     current input file name, with the .gk suffix appended to it.  */
8235
8236 static const char *
8237 compare_debug_auxbase_opt_spec_function (int arg,
8238                                          const char **argv)
8239 {
8240   char *name;
8241   int len;
8242
8243   if (arg == 0)
8244     fatal_error ("too few arguments to %%:compare-debug-auxbase-opt");
8245
8246   if (arg != 1)
8247     fatal_error ("too many arguments to %%:compare-debug-auxbase-opt");
8248
8249   if (compare_debug >= 0)
8250     return NULL;
8251
8252   len = strlen (argv[0]);
8253   if (len < 3 || strcmp (argv[0] + len - 3, ".gk") != 0)
8254     fatal_error ("argument to %%:compare-debug-auxbase-opt "
8255                  "does not end in .gk");
8256
8257   if (debug_auxbase_opt)
8258     return debug_auxbase_opt;
8259
8260 #define OPT "-auxbase "
8261
8262   len -= 3;
8263   name = (char*) xmalloc (sizeof (OPT) + len);
8264   memcpy (name, OPT, sizeof (OPT) - 1);
8265   memcpy (name + sizeof (OPT) - 1, argv[0], len);
8266   name[sizeof (OPT) - 1 + len] = '\0';
8267
8268 #undef OPT
8269
8270   return name;
8271 }
8272
8273 /* %:pass-through-libs spec function.  Finds all -l options and input
8274    file names in the lib spec passed to it, and makes a list of them
8275    prepended with the plugin option to cause them to be passed through
8276    to the final link after all the new object files have been added.  */
8277
8278 const char *
8279 pass_through_libs_spec_func (int argc, const char **argv)
8280 {
8281   char *prepended = xstrdup (" ");
8282   int n;
8283   /* Shlemiel the painter's algorithm.  Innately horrible, but at least
8284      we know that there will never be more than a handful of strings to
8285      concat, and it's only once per run, so it's not worth optimising.  */
8286   for (n = 0; n < argc; n++)
8287     {
8288       char *old = prepended;
8289       /* Anything that isn't an option is a full path to an output
8290          file; pass it through if it ends in '.a'.  Among options,
8291          pass only -l.  */
8292       if (argv[n][0] == '-' && argv[n][1] == 'l')
8293         {
8294           const char *lopt = argv[n] + 2;
8295           /* Handle both joined and non-joined -l options.  If for any
8296              reason there's a trailing -l with no joined or following
8297              arg just discard it.  */
8298           if (!*lopt && ++n >= argc)
8299             break;
8300           else if (!*lopt)
8301             lopt = argv[n];
8302           prepended = concat (prepended, "-plugin-opt=-pass-through=-l",
8303                 lopt, " ", NULL);
8304         }
8305       else if (!strcmp (".a", argv[n] + strlen (argv[n]) - 2))
8306         {
8307           prepended = concat (prepended, "-plugin-opt=-pass-through=",
8308                 argv[n], " ", NULL);
8309         }
8310       if (prepended != old)
8311         free (old);
8312     }
8313   return prepended;
8314 }