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