gcc/gcc.c

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