gcc/gcc.c

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