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