gcc/gcc.c

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