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