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