contrib/gcc/gcc.c

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