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