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