gcc/gcc.c

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