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