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