gcc/gcc.c

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