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