gcc/gcc.c

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