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