gcc/gcc.c

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