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