gcc/gcc.c

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