gcc/gcc.c

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