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