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