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