gcc/gcc.c

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