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