gcc/gcc.c

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